Constructors, Destructors & Initialization Order

A constructor is an object's factory contract: it transforms raw, uninitialized memory bits into a valid working instance.

1. Default & Parameterized: A default constructor takes zero arguments (or provides defaults for all). If you write any custom constructor, the compiler removes its automatic default constructor unless you explicitly restore it with = default.
2. Delegating Constructors (C++11): One constructor can delegate work to another constructor in the same class via its initializer list (: ServerConfig(...)). This centralizes validation in one canonical constructor without duplicate logic.
3. The Construction Milestone: As soon as the delegated target constructor's closing brace } finishes, the object is formally fully constructed. If the caller's body throws an exception afterward, the class destructor ~T() will run during stack unwinding.

In C++, any constructor callable with a single argument acts as an automatic implicit type-conversion operator by default.

1. The Silent Conversion Trap: If a class defines Buffer(int size), passing the integer 42 to a function expecting void send(Buffer b) compiles without warnings—silently allocating a 42-byte heap buffer behind your back!
2. The explicit Shield: Prefixing the constructor with explicit instructs the compiler to forbid implicit conversions and copy-initialization syntax (Buffer b = 42;).
3. Enforced Direct Initialization: Callers must explicitly request construction (Buffer b(42); or Buffer b{42};), eliminating unexpected temporary objects and expensive hidden allocations.

Using the Member Initializer List constructs fields directly in-place. Assigning inside the constructor body {} is not true initialization—it is reassignment after default creation.

Initializer lists are mandatory in three situations:

1. const data members: Read-only variables that cannot be reassigned once created.
2. Reference members (T&): Aliases that must bind to an existing variable at birth; they can never be reseated.
3. Types lacking default constructors: Subobjects that cannot be instantiated 'empty' before entering the {} body.

For standard types like std::string or std::vector, writing name_ = val; inside {} triggers double initialization: the default constructor runs first to allocate an empty buffer, and then the assignment operator destroys it to copy new data. The initializer list executes direct in-place construction in a single step.

Non-static class members are always initialized in the order they are declared in the class definition, completely ignoring their ordering in the member initializer list.

Consider this frequent production bug:

class Bad {
    int b_;
    int a_;
public:
    Bad(int val) : a_(val), b_(a_ * 2) {} // BUG!
};

1. The Trap: Because b_ is declared before a_ in the class body, b_ is constructed first.
2. Garbage Evaluation: When b_(a_ * 2) runs, a_ has not been initialized yet. b_ reads uninitialized stack garbage.
3. The Fix: Always order class header declarations to match dependencies, and keep the initializer list in identical sequence. Modern compilers emit a -Wreorder warning when these sequences diverge.

C++ executes object construction and destruction like a strict LIFO stack (like a stack of cafeteria trays):

Construction Sequence (Base to Derived):

1. Virtual Base Classes: Constructed first in depth-first, left-to-right traversal.
2. Direct Base Classes: Constructed left-to-right in inheritance declaration order.
3. Member Objects: Constructed in class declaration order.
4. Derived Constructor Body {}: Runs last once all subobjects exist.

Destruction Sequence (Exact Reverse Mirror):

1. Derived Destructor Body ~Derived() {}: Cleans up derived state first.
2. Member Objects: Destroyed in reverse declaration order.
3. Direct Base Classes: Destroyed in reverse inheritance order.
4. Virtual Base Classes: Destroyed last in reverse order.

This guarantees that while any destructor runs, all base classes and member fields remain 100% valid and accessible.