Member Initializer Lists

In previous lessons, we saw how we could initialize the members of our classes to different values, using 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, that we can use with constructors. This syntax is called a member initializer list.

The previous example, where we initialize our Health to 100 from the constructor, can be written using a member initializer list 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 can provide a function body for our constructor. It can be blank as in the above example, or we can put any other code in there that we want to run when our objects are first created.

If we do not need to provide a body, we still have to include the braces { and }.

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 set to some default value before. 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, we will immediately understand what that part of the code is doing when reading other 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.

Where 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 parameters passed in by the code seeking to construct an object from our class:

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

With member initializer lists, we can set our constructors 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.