The member initializer list for a class constructor allows members to be initialized to specified values and for base class constructors to be called with specific arguments. However, the order in which initialization occurs is fixed and does not depend on the order written in the member initializer list. The C++ Standard, [class.base.init], paragraph 11 [ISO/IEC 14882-2014], states the following:
In a non-delegating constructor, initialization proceeds in the following order:
— First, and only for the constructor of the most derived class, virtual base classes are initialized in the order they appear on a depth-first left-to-right traversal of the directed acyclic graph of base classes, where “left-to-right” is the order of appearance of the base classes in the derived class base-specifier-list.
— Then, direct base classes are initialized in declaration order as they appear in the base-specifier-list (regardless of the order of the mem-initializers).
— Then, non-static data members are initialized in the order they were declared in the class definition (again regardless of the order of the mem-initializers).
— Finally, the compound-statement of the constructor body is executed.
[Note: The declaration order is mandated to ensure that base and member subobjects are destroyed in the reverse order of initialization. —end note]
Consequently, the order in which member initializers appear in the member initializer list is irrelevant. The order in which members are initialized, including base class initialization, is determined by the declaration order of the class member variables or the base class specifier list. Writing member initializers other than in canonical order can result in undefined behavior, such as reading uninitialized memory.
Always write member initializers in a constructor in the canonical order: first, direct base classes in the order in which they appear in the base-specifier-list for the class, then nonstatic data members in the order in which they are declared in the class definition.
Noncompliant Code Example
In this noncompliant code example, the member initializer list for
C::C() attempts to initialize
someVal first and then to initialize
dependsOnSomeVal to a value dependent on
someVal. Because the declaration order of the member variables does not match the member initializer order, attempting to read the value of
someVal results in an unspecified value being stored into dependsOnSomeVal.
This compliant solution changes the declaration order of the class member variables so that the dependency can be ordered properly in the constructor's member initializer list.
It is reasonable for initializers to depend on previously initialized values.
Noncompliant Code Example
In this noncompliant code example, the derived class,
D, attempts to initialize the base class,
B1, with a value obtained from the base class,
B2. However, because
B1 is initialized before
B2 due to the declaration order in the base class specifier list, the resulting behavior is undefined.
This compliant solution initializes both base classes using the same value from the constructor's parameter list instead of relying on the initialization order of the base classes.
OOP53-CPP-EX0: Constructors that do not use member initializers do not violate this rule.
|Axivion Bauhaus Suite|
|LDRA tool suite|
|List members in an initialization list in the order in which they are declared|
|Polyspace Bug Finder|
|CERT C++: OOP53-CPP||Checks for members not initialized in canonical order (rule fully covered)|
|SonarQube C/C++ Plugin|
|[ISO/IEC 14882-2014]||Subclause 12.6.2, "Initializing Bases and Members"|
|[Lockheed Martin 2005]||AV Rule 75, Members of the initialization list shall be listed in the order in which they are declared in the class|