What is a constructor initialization list?

Answer 1

The constructor initialisation list is the most efficient method of initialising class members, including primitive members. You use it always and without exception to ensure efficient construction.

Consider the following:

class foo

{

int m_data;

public:

foo(int data=0){ m_data=data; }

foo(const foo& f){ m_data=f.m_data; }

};

This class employs inefficient construction technique by initialising the member variables in the constructor bodies rather than the initialisation list. In other words, m_data is instantiated and initialised in two stages instead of one. It is not unlike the following two stage initialisation:

int m_data;

m_data =0;

A more efficient way of writing these lines is to initialise at the point of instantiation using a compound statement:

int m_data=0;

The same applies to class construction. By using the initialisation list, member variables are initialised at the point of instantiation, as per the following:

class foo

{

int m_data;

public:

foo(int data=0):m_data(data) {}

foo(const foo& f):m_data(f.m_data) {}

};

You will note that primitive members use object-oriented syntax in the initialisation list. This is not merely sugar-coating -- it applies to all members, including base classes. This makes it possible to invoke specific base class constructors, rather than the default constructor that would be implicitly invoked (or the base class copy constructor in the case of a derived class copy constructor).

Consider the following:

class base

{

int m_data;

public:

base(int data=0):m_data(data) {}

base(const base& b):m_data(b.m_data) {}

};

class derived : public base

{

public:

derived(int data=0):base(data) {}

derived(const derived& d):base(d) {}

};

Note how the derived class default constructor invokes the base class default constructor, but passes the data argument to it. Had you not used the initialisation list you'd have to construct base, then derived, and then initialise the base class member via a setter. Clearly the initialisation list is more efficient because the base class can be initialised before derived is even instantiated, which cannot happen until the base class is fully-instantiated.

Note also that the copy constructor specifically invokes the base class copy constructor. Although the argument, d, is not a base class, it is a type of base class, thus there is no need to upcast the argument.

Ultimately, it can be seen that the constructor bodies are largely redundant. You still need a constructor body, even an empty one, but most of the time you will use the body for debug trace code. There will be times, however, where the class initialisation list cannot fully initialise a member because one or more arguments require more complex processing (such as calling a complex setter). In this case, you must use the constructor body. However, you must still perform as much initialisation as is possible via the initialisation list to ensure the most efficient construction method. Only those members that require additional processing need not be initialised, but it costs nothing to initialise them to an arbitrary or default value.

The initialisation list is vital in the case of the copy constructor, as passing an object to a function by value will automatically invoke the copy constructor. If any member variables are embedded objects, or the object is derived from one or more base classes, then their copy constructors will be invoked as well. Therefore it pays to make construction as efficient as possible when copying objects. However, the same applies to any constructor. The more efficient the constructor performs, the better your programs will perform, especially in complex hierarchies where objects may be deeply embedded within other objects that are themselves embedded.

Answer 2

A constructor initialisation list provides the primary means by which class member data is initialised.

Consider the following class definition:

class X {

std::string x;

public:

X (string s) { x=s; }

X (int i=0) { x=to_string(i); }

// ...

};

The member variable x is a user-defined type with a default constructor. As such, x is constructed and initialised before we even reach the constructor body, which is where we perform the actual initialisation. In other words we're performing a two-stage initialisation which can be highly inefficient depending on the complexity of the object we are initialising.

By using an initialisation list we can completely remove the inefficiency:

class X {

std::string x;

public:

X (string s): x {s} {}

X (int i): x {to_string(i)} {}

// ...

};

The initialisation list appears between the closing parenthesis of the argument list and the opening brace of the constructor body, prefixed with a colon. Note that the constructor bodies are now empty. Ideally, we should perform as much initialisation as we possibly can before we enter the constructor body.

In the example above, there is only one member to initialise. If we needed to initialise other members we'd use a comma-separated list of initialisers.

Note that we use braces {} to indicate that an initialisation is taking place. In reality we are actually constructing x via copy construction, so we could have written the list using parenthesis notation:

class X {

std::string x;

public:

X (string s): x (s) {}

X (int i): x (to_string(i)) {}

// ...

};

Whether you use braces or parenthesis is a matter of personal choice. However, there are cases where the notation will change the meaning:

std::vector<int> x {3, 4}; // two elements with values 3 and 4

std::vector<int> y (3, 4); // three elements with value 4

In essence, these are invoking two different constructors:

std::vector<T> (std::initializer_list<T>);

std::vector<T> (size_t size, T value);

Note that a std::initializer_list object is in no way related to a constructor initialiser list.

As well as initialising class member data we can use the initialisation list to initialise base classes:

class Base {

int x;

protected:

Base (int i): x {i} {}

// ...

};

class Derived : public Base {

D (int i): Base {i} {}

};

Note that a derived class cannot directly initialise a private member of its base class, but as long as there's a protected or public constructor available we can invoke that instead.

We can also write one constructor in terms of another:

class X {

int x;

public:

X (int i=0): x {i} {}

X (double d): X {(int) d} {}

// ...

};

Here, the constructor that accepts a double delegates to the default constructor accepting an integer.

Note that base classes and member data must be initialised in the order they are declared. Derived classes are always constructed beginning with the least-derived class. This means that until we reach the constructor body proper the object is only partially constructed. However, the object only becomes a valid object when we return from the constructor body. If an exception is thrown before we return from the constructor body, all objects constructed up to the point of the throw are implicitly destroyed and the object ceases to exist. The call stack will unwind until a suitable handler is found. We can obviously use a try-catch block to catch any exceptions thrown by the constructor body itself, but if we want to catch exceptions thrown by class member constructors we must place the initialiser list itself in a try-catch block:

class X {

std::vector<int> vi;

std::vector<std::string> vs;

public:

X (int, int);

};

X::X (int sz1, int sz2)

try

: vi (sz1), // construct vi with sz1 integers

vs (sz2) // construct vs with sz2 strings

{

// normal construction body goes here

}

catch (std::exception& err)

{

// handle exceptions thrown by the vi or vs initialisers here

}