- Learn C++ Test Site - https://test.learncpp.com -

10.1 — Constructor initialization lists

Up until now, we’ve been initializing our class member data in the constructor using the assignment operator. For example:

When the class’s constructor is executed, m_nValue, m_dValue, and m_chValue are created. Then the body of the constructor is run, where the member data variables are assigned values. This is similar to the flow of the following code in non-object-oriented C++:

While this does not exhibit good style, it is valid within the syntax of the C++ language.

So far, the classes that we have written have only included non-const or pointer member variables. However, what happens when we want to use const or reference variables as member variables? As you have learned in previous lessons, const and reference variables must be initialized on the line they are declared. Consider the following example:

This produces code similar to the following:

Consequently, assigning const or reference member variables values in the body of the constructor is not sufficient.

Initialization lists

C++ provides another way of initializing member variables that allows us to initialize member variables when they are created rather than afterwards. This is done through use of an initialization list.

In the lesson on basic addressing and variable declaration [1], you learned that you could assign values to variables in two ways: explicitly and implicitly:

Using an initialization list is very similar to doing implicit assignments.

Let’s take a look at our top example again. Here’s the code that does explicit assignments in the constructor body:

Now let’s write the same code using an initialization list:

The initialization list is inserted after the constructor parameters, begins with a colon (:), and then lists each variable to initialize along with the value for that variable separated by a comma. Note that we no longer need to do the explicit assignments in the constructor body, since the initialization list replaces that functionality. Also note that the initialization list does not end in a semicolon.

Here’s an example of a class that has a const member variable:

We strongly encourage you to begin using this new syntax (even if you aren’t using const or reference member variables) as initialization lists are required when doing composition and inheritance (subjects we will be covering shortly).

10.2 -- Composition [2]
Index [3]
9.12 -- Shallow vs. deep copying [4]