C++ Member Initialiser Lists

In previous lessons, we saw how we could initialise the members of our classes to different values, using a constructor:

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

This method does have a slight performance cost, as, when our objects are created from our class, the initialisation of the variable is done in two steps rather than one.

First, the variable is declared and memory is assigned for it. Then, later, when we get to the relevant line in our constructor function, a second statement changes the value in that memory location.

Aside from being sub-optimal, this is also unusable for references. As we saw in the previous lesson, references must be initialised with a value, and that value cannot be reassigned.

1class Weapon {};
2class Character {
3public:
4  Character() {
5    Weapon InitialWeapon;
6    EquippedWeapon = InitialWeapon;
7  }
8
9  Weapon& EquippedWeapon;
10};
11

1Character MyCharacter;
2

1Weapon MyWeapon;
2Character MyCharacter { MyWeapon };
3

The way we can solve this is to use a Member Initialiser List - a special syntax that we can attach to our constructor functions, to ensure our member variables are initialised in one step.

Defining Member Initialiser Lists in C++

The way in which we achieve the above example using a member initialiser list is as follows:

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

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

We still can provide a function body. 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    Damage = 100;
5  }
6
7  int Damage;
8};
9

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

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

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

Where we want to initialise multiple variables, we can add those to the list, separated by commas:

1class Character {
2public:
3  Character() : Health{ 150 }, Armor{ 0.5f } {
4    // Body here
5  }
6
7private:
8  int Health;
9  float Armour;
10}
11

Like with the initialisation 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 for humans.

1float GetArmour() { return 0.25f; };
2
3class Character {
4public:
5  Character() :
6    Health{ 100 + 50 },
7    Armour{ GetArmour() }
8  {
9    // Body here
10  }
11
12private:
13  int Health;
14  float Armour;
15}
16

Using Parameters in C++ Member Initialiser Lists

Of course, the above examples are slightly unnecessary. If we wanted all our objects to be initialised with the same value, we wouldn't need an initialiser list (or a constructor) at all - we could just do this:

1class Character {
2  int Health { 150 };
3  float Armour { 0.5f };
4}
5

However, the strength of initialising variables from constructors is that each object can be initialised with different values, based on parameters passed to the constructor.

1Character SmallCharacter { 150, 0.25f };
2Character BigCharacter { 300, 0.5f };
3

With member initialiser lists, we can set our constructors up to support this as follows:

1class Character {
2public:
3  Character(int InitialHealth, float InitialArmour) :
4    Health{ InitialHealth },
5    Armour{ InitialArmour }
6  {
7    // Body here
8  }
9
10private:
11  int Health;
12  float Armour;
13}
14

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

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

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

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

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

Initialising References in C++ Classes

This knowledge allows us to address our original problem. We can now store references to other objects from within our class.

We do this by using a member initialiser list to initialise the reference from an argument passed to the constructor:

1class Weapon {};
2class Character {
3public:
4  Character(Weapon& Weapon) :
5    EquippedWeapon{ Weapon }
6  {
7    // Body here
8  }
9
10private:
11  Weapon& EquippedWeapon;
12}
13

We can then create our objects like this:

1Weapon SteelSword;
2Character Goblin { SteelSword };
3