C++ Member Initializers vs Constructor Initializer Lists

In C++, non-static data members can be initialized directly at the point of declaration using default member initializers, or initialized during object construction using constructor member initializer lists. When both mechanisms are present in the same class, the constructor member initializer list always takes precedence over the default member initializer. Understanding how these two initialization forms interact ensures consistent object state, prevents redundant evaluations, and avoids subtle bugs related to member initialization order.

The Overriding Precedence Rule

The interaction between default member initializers and constructor initialization lists is governed by a strict hierarchy:

1. Explicit Initialization: If a constructor's member initializer list explicitly names a data member, the constructor initialization expression is evaluated and used. The default member initializer for that specific field is completely ignored.
2. Fallback to Default: If a constructor omits a member from its initializer list, the compiler automatically uses the default member initializer provided in the class definition.
3. Default Initialization (No Initializer): If neither an explicit constructor initializer nor a default member initializer exists, the member undergoes default initialization (which leaves primitive types with indeterminate values if the constructor performs no initialization in its body).

struct Configuration {
    int timeout = 30; // Default member initializer
    int retries = 3;  // Default member initializer

    // Uses default member initializers: timeout = 30, retries = 3
    Configuration() = default;

    // Overrides timeout to 60; falls back to retries = 3
    Configuration(int t) : timeout(t) {}

    // Overrides both members: timeout = t, retries = r
    Configuration(int t, int r) : timeout(t), retries(r) {}
};

Order of Initialization

A common misconception is that default member initializers are processed before the constructor body or in a different order relative to the constructor's list.

In C++, member variables are always initialized in the exact order they are declared within the class definition, regardless of:

• The order in which they appear in a constructor's member initializer list.
• Whether a member uses a default initializer or an initializer list entry.

struct Sequence {
    int a = 1;
    int b = 2;

    // 'a' is initialized first, then 'b' is initialized,
    // regardless of the list order below.
    Sequence() : b(20), a(10) {}
};

Because declaration order strictly controls initialization, referencing one member to initialize another must adhere to the declaration sequence to prevent reading uninitialized memory.

Evaluation and Side Effects

Expressions inside default member initializers are evaluated only if they are actually used. If a constructor provides an explicit initializer for a member, the default initializer's expression is discarded entirely. Any function calls or side effects defined within the default member initializer will not occur.

int getDefaultPort() {
    // Some computationally expensive operation or side effect
    return 8080;
}

struct Server {
    int port = getDefaultPort();

    // getDefaultPort() is NOT called; port is set directly to 443
    Server() : port(443) {}

    // getDefaultPort() IS called; port is set to 8080
    Server(bool useDefault) {}
};

Aggregates and Delegating Constructors

The relationship between these initializers also extends to specific language features:

• Delegating Constructors: When a constructor delegates to another constructor (e.g., MyClass() : MyClass(42) {}), the target constructor handles all initializations. Default member initializers are applied only to fields that the target constructor does not initialize.
• Aggregate Initialization: If a class qualifies as an aggregate type, designated initializers or brace-enclosed values take precedence over default member initializers. Any member omitted from the aggregate initialization list falls back to its default member initializer.

struct Options {
    bool logging = true;
    int verbosity = 1;
};

// 'logging' is overridden to false; 'verbosity' falls back to 1
Options opt{false}; 

Practical Application

Use default member initializers to establish sensible, invariant defaults across all constructors. Reserve constructor initialization lists for parameters that vary per instance or depend on runtime arguments passed to the constructor. This pattern eliminates repetitive member assignments across overloaded constructors while allowing targeted overrides when necessary.