Member Initializer Lists

In previous lessons, we saw how we could initialize the members of our classes to specific values within the body of a constructor:

1class Character {
2public:
3  Character() {
4    mHealth = 100;
5  }
6
7private:
8  int mHealth;
9};

C++ provides a dedicated syntax for this purpose called a member initializer list.

The previous example, where we initialize our Health to 100 from the constructor, can instead be written using a member initializer list. It would look like this:

1class Character {
2public:
3  Character() : mHealth{ 150 } {
4    // Body here
5  }
6
7private:
8  int mHealth;
9};

We place the initializer list between the name and the body of the function, separated by a :.

We still provide a function body for our constructor, within a set of { and } as usual. It can be blank as in the above example, or we can put any other code we might need in there.

1class Weapon {
2public:
3  Weapon() {
4    mDamage = 150;
5  }
6
7  int mDamage;
8};

1class Weapon {
2public:
3  Weapon() : mDamage { 150 };
4
5  int mDamage;
6};

1class Weapon {
2public:
3  Weapon() : mDamage { 150 } {}
4
5  int mDamage;
6};

1class Weapon {
2public:
3  Weapon(int Damage = 150) {
4    mDamage = Damage;
5  };
6
7  int mDamage;
8};

Member initializer lists have three main advantages over writing equivalent code in the constructor body:

Performance

Due to nuance in how objects are constructed, initializing variables in a constructor body is slightly slower than it needs to be.

When our object is created, memory is assigned for its variables, and initially set to some default value. This happens before our constructor body is executed. If our constructor body then changes the value of those variables, we have to revisit and update those memory locations.

By specifying initial values in a dedicated initializer list, the compiler can identify and optimize that process to a single step.

Code Readability

Member initializer lists are dedicated to initializing our class members.

Once we get familiar with the syntax, this means we will immediately understand what that part of the code is doing when scanning through files.

It's Sometimes Required

In some scenarios, using a member initializer list is required to get the desired functionality. We'll see an example of this in the next lesson, and more examples later in the course.

If we want to initialize multiple class variables, we can add those to the list, separated by commas:

1class Character {
2public:
3  Character() : mHealth{ 150 }, mLevel{ 5 } {
4    // Body here
5  }
6
7private:
8  int mHealth;
9  int mLevel;
10};

Like with the initialization of any other variables, any expression that results in a value of the correct type can be used. This is shown in the below example.

Remember, C++ is not especially sensitive to white space, so we can generally add line breaks and additional space where needed if we think it makes our code more readable:

1int GetLevel() { return 5; }
2
3class Character {
4public:
5  Character() :
6    mHealth{ 100 + 50 },
7    mLevel{ GetLevel() }
8  {
9    // Body here
10  }
11
12private:
13  int mHealth;
14  int mLevel;
15};

Of course, the above examples are slightly unnecessary. The previous examples don't need an initializer list or a constructor at all - we could just do this:

1class Character {
2  int mHealth { 100 + 50 };
3  int mLevel { GetLevel() };
4};

However, the strength of initializing variables from constructors is that we can use the arguments provided to the constructor. Below, we have a request to create two Character objects, where each request is passing two arguments to a hypothetical constructor:

1Character SmallCharacter { 150, 5 };
2Character BigCharacter { 300, 15 };

With member initializer lists, we can set our constructor up to support this as follows:

1class Character {
2public:
3  Character(int Health, int Level) :
4    mHealth{Health},
5    mLevel{Level}
6  {
7    // Body here
8  }
9
10private:
11  int mHealth;
12  int mLevel;
13};

1class Weapon {
2public:
3  Weapon(int Damage) {
4    mDamage = Damage;
5  }
6
7  int mDamage;
8};

1class Weapon {
2public:
3  Weapon(int Damage): mDamage { Damage } {}
4
5  int mDamage;
6};

1class Weapon {
2public:
3  Weapon(int Damage): Damage { mDamage } {}
4
5  int mDamage;
6};

1class Weapon {
2public:
3  Weapon(int mDamage = Damage) {}
4
5  int mDamage;
6};

1class Weapon {
2public:
3  Weapon(int Damage = 150) {
4    mDamage = Damage;
5  }
6
7  int Damage;
8};

In this lesson, we explored the use of Member Initializer Lists. We learned that these lists offer a more efficient way to initialize class members, enhancing both performance and code readability. Key points include:

• Member Initializer Lists allow for direct initialization of class members.
• They provide performance benefits by reducing the number of operations during object creation.
• These lists enhance code clarity, making the initialization intent explicit.
• In certain scenarios, Member Initializer Lists are necessary for correct class functionality.
• We can initialize multiple members and use expressions and constructor parameters in these lists.