When do we use Member Initializer List in C++?

Are you still performing assignments in the body of the constructor? You are likely missing a lot in terms of powerful optimizations and safety that member initializer lists introduce in C++. They are advantageous for performance and ensure the correct initialization of const members, references, and non-default-constructible objects. Read this blog to see how this small change can render your code cleaner, safer, and faster!

Table of Contents:

• What is the Member Initializer List in C++?
• Key Reasons to Prefer Member Initializer Lists
  1. Required for const Data Members
  2. Required for Reference(&) Data Members
  3. Required for Member Objects Without a Default Constructor
  4. Required for Initializing Base Class Members in Derived Classes
  5. Prevents Naming Conflicts Between Constructor Parameters and Class Members
  6. Better Performance
  7. Prevents Narrowing Conversions and Ensures Type Safety
• Conclusion

What is the Member Initializer List in C++?

In C++, the member initializer list is a process to initialize the class members before the constructor body executes. It is assigned after the constructor’s parameter list and before the constructor’s body. It is declared by using a colon (:) followed by a comma-separated list of initializations. 

Example: 

Output: 

In the above code, if the object is created as a member initialized list(: name(n), age(a)) instead of assigning the values inside the constructor’s body.  We already defined a person’s class with two data members: name and age, i.e., one is a string(name), and the other is an integer(age). 

In the main() function, we create a Person object p1 with the name “Intellipaat” and age 25. These values are passed to the constructor and directly used to initialize the name and age members. The display() function then prints: Name: Intellipaat, Age: 25.

Key Reasons to Use Member Initializer Lists

1. Required for const Data Members 

The data members of a const should be initialized at the time of object construction, and this initialization can only be done using an initializer list. 

Example:

Output: 

In the above code, the test class t has an integer member that is const, these must be initialized using a member-initialized list (: t(t)). Because it’s impossible to modify the const members after the object creation. In the main() function, the object t1 of the test is created with the value 10. Using the getT() function, we can print the value of t.   

2. Required for Reference(&) Data Members 

In C++, the reference members should be initialized only when the object is created, the same as the previous approach. The initialization can also be done using an initializer list. 

Example: 

Output: 

In the above code, the class test has a reference member t. By using the member initialization list, the initialization can be done. Because the reference member must be bound during the object construction. In the main() function, the object t1 is created with a reference to x, and the value of t is printed, First, it prints 20, and after modification, it prints 30.

3. Required for Member Objects Without a Default Constructor 

An initializer list is used when a class contains an object of another class that does not have a default constructor.

Example: 

Output: 

In the above code, class B has a member object of class A, but class A does not have a default constructor. Using the member initializer list, the a should be initialized in the B constructor. If an object of class B is created with 10, first it calls the A constructor for initialization. Only after constructing the object, the B constructor calls the message printed.

4. Required for Initializing Base Class Members in Derived Classes 

In C++, the initializer list is required when a derived class has to initialize a base class using a parameterized constructor.

Example:

Output: 

In the above code, class B inherits from class A and uses the initializer list in the constructor to call the A constructor with the parameter x. If an object of B is assigned 10, it first initializes the base class A. After that, the message B constructor is called and printed. 

5. Prevents Naming Conflicts Between Constructor Parameters and Class Members

An initializer list is required in some cases, such as if a constructor parameter name is the same as the data member name.  

Example: 

Output: 

In the above code, class A has a data member i and uses the constructor initializer list(: i(i)) to initialize the i. The assigned constructor avoids naming conflicts that occur between the parameter i and the member variable i. In the main function, an object a from class A is assigned with value 10, and the getI() function is called to print the value, which is 10.

6. Better Performance 

To avoid unnecessary assignments inside the constructor body, we have to use an initializer list to make the code effective.

Example: 

Output: 

In the above code, through its constructor, the class Type has assigned an integer member value. The Myclass class contains a variable of type Type, and the constructor initializes the variable using a member initializer list. In the main function, a Type t1 with a value of 10 is assigned and passed to the Myclass constructor. The display () method is used to print the value of a variable that is 10. 

7. Prevents Narrowing Conversions and Ensures Type Safety 

We should use uniform initialization({ }) with initializer lists to prevent unintended type conversions.

Example:

Output: 

The value 44 is passed to the base constructor in the above code, but 44 is outside the valid range for a char. This results in wrapping or truncating the value, i.e., narrowing conversion. This may cause unexpected behavior when printing. 

Conclusion 

In C++, using member initializer lists is effective and preferred because they make sure that there is a proper initialization of const members and references. The member initializer lists avoid the redundant default initialization and also improve performance by eliminating the extra assignments. And prevent unintended type conversions, which result in cleaner, safer, and more efficient code. 

You can learn more about C++ in the C++ programming language and also explore C++ Interview Questions prepared by industry experts.

FAQs on Key Reasons to Use Member Initializer Lists in C++