An object of a class with only public members and no constructors or base classes (typically a structure) can be initialized with an initializer list. If a class has a constructor, its objects must be either initialized or have a default constructor. The latter is used for objects not explicitly initialized. 

Objects of classes with constructors can be initialized with an expression list in parentheses. This list is used as an argument list to the constructor. An alternative is to use an equal sign followed by a single value. The single value can be the same type as the first argument accepted by a constructor of that class, in which case either there are no additional arguments, or the remaining arguments have default values. It could also be an object of that class type. In the former case, the matching constructor is called to create the object. In the latter case, the copy constructor is called to initialize the object.

class X 
{
   int i;
public:
   X();         // function bodies omitted for clarity
   X(int x);
   X(const X&);
};
void main() 
{
   X one;        // default constructor invoked
   X two(1);     // constructor X::X(int) is used
   X three = 1;  // calls X::X(int)
   X four = one; // invokes X::X(const X&) for copy
   X five(two);  // calls X::X(const X&)
}

The constructor can assign values to its members in two ways: 

1. It can accept the values as parameters and make assignments to the member variables within the function body of the constructor:

class X
{
   int a, b;
public:
   X(int i, int j) { a = i; b = j }
};

2. An initializer list can be used prior to the function body:

class X
{
   int a, b, &c;  // Note the reference variable.
public:
   X(int i, int j) : a(i), b(j), c(a) {}
};

The initializer list is the only place to initialize a reference variable. 

In both cases, an initialization of X x(1, 2) assigns a value of 1 to x::a and 2 to x::b. The second method, the initializer list, provides a mechanism for passing values along to base class constructors.

class base1
{
   int x;
public:
   base1(int i) { x = i; }
};
class base2
{
   int x;
public:
   base2(int i) : x(i) {}
};
class top : public base1, public base2
{
   int a, b;
public:
   top(int i, int j) : base1(i*5), base2(j+i), a(i) { b = j;}
};

With this class hierarchy, a declaration of top one(1, 2) would result in the initialization of base1 with the value 5 and base2 with the value 3. The methods of initialization can be intermixed. 

As described previously, the base classes are initialized in declaration order. Then the members are initialized, also in declaration order, independent of the initialization list.

class X
{
  int a, b;
public:
  X(int i, j) :  a(i), b(a+j) {}
};

With this class, a declaration of X x(1,1) results in an assignment of 1 to x::a and 2 to x::b. 

Base class constructors are called prior to the construction of any of the derived classes members. If the values of the derived class are changed, they will have no effect on the creation of the base class.

class base
{
   int x;
public:
   base(int i) : x(i) {}
};
class derived : base
{
   int a;
public:
   derived(int i) : a(i*10), base(a) { } // Watch out! Base will be
                                         // passed an uninitialized ’a’
};

With this class setup, a call of derived d(1) will not result in a value of 10 for the base class member x. The value passed to the base class constructor will be undefined. 

When you want an initializer list in a non-inline constructor, don’t place the list in the class definition. Instead, put it at the point at which the function is defined.

derived::derived(int i) : a(i)
{
  .
  .
  .
}