What is the difference between using initialization lists to initialize fields and initialize them inside the constructor?

Question

On some tutorials (e.g. http://www.tutorialspoint.com/cplusplus/cpp_constructor_destructor.htm) I read that the following two codes are equivalent.

First code:

class MyClass1{
    public:
        int a;
        int b;
        MyClass1(int a, int b) : a(a), b(b) {};
};

Second code:

class MyClass2{
    public:
        int a;
        int b;
        MyClass2(int, int);
};

MyClass2::MyClass2(int a, int b){
    this->a = a;
    this->b = b;
}

In fact, they give me the same results. But, if I use const members I'm not able to compile the code anymore.

class MyClass1{
    public:
        const int a;
        const int b;
        MyClass1(int a, int b) : a(a), b(b) {};
};

class MyClass2{
    public:
        const int a;
        const int b;
        MyClass2(int, int);
};

MyClass2::MyClass2(int a, int b){
    this->a = a;
    this->b = b;
}

In fact the first class give me no error but in the second class there is an assignment of read-only member. So, these are the questions:

What is the real difference among the two methods of initialization?

Is using the initialization lists the only method to initialize const members of a class?

Note: I read online the use of delegating constructors to avoid this problem but it's not clear for me their use and what they really do.

Answer 1

A simple way of looking at it is to make connections with local variables:

1. Using initializer lists is equivalent to this view of local variables:

   int a = 1;
   int b = 2;
   

2. The second form, assigning them inside constructor is equivalent to this:

   int a;
   int b;
   
   a = 1;
   b = 2;
   

You can see how this can be a problem with const or with objects that don't have a default constructor:

Const members

1. Ok:

   const int a = 1;
   const int b = 2;
   

2. Not ok:

   const int a;
   const int b;
   a = 1;
   b = 2;
   

Types with deleted or not accessible default constructor

e.g.:

class X {
public:
   X() = delete; // default constructor deleted
   X(int){};     // constructor with an int parameter
};

1. Ok:

   X x(1);
   

2. Not ok:

   X x;
   x = X(1);
   

3rd option: In-class member initializers (since c++11)

class A {
public:
   const int a = 10;
};

Answer 2

You don't actually ever initialise any member varaibles in the constructor body, that's the chief difference.

All base members are initialised before the constructor body is entered. The initialiser list helps you do that. If any members are missing from the initialiser list then they are default constructed, aside from POD types which are not initialised. If a member does not have an accessible default constructor, then you must include it in the initialiser list with appropriate arguments.

Note that the order of initialisation of members in a base member initialisation list is not the order that they appear in the initialisation list itself, but the order they appear in the class declaration: If you had written MyClass1(int a, int b) : b(b), a(a) {}; then a would still be initialised first. It's very important that you remember that.

Using base member initialisation whenever possible is preferred as it tends to lead to greater program stability.

Answer 3

In the first case when a data member is initialized in the mem-initializer list there is called its constructor, that is the data member is created.

In the second case at first data members are default initialized and then there is used the corresponding copy assignment operator. That is in the second case there are to steps of the process:

1. creating an object with the default constructor;
2. calling the copy assignment operator to assign a value to the object.

For example constant objects or references shall be initialized when they are created. So you may not at first create them without an initializer using the default constructor and then reassign them. Or for example an object can have no default costructor. In this case you have to initialize it explicitly in the mem-initializer list using a constructor with parameters.