C++类嵌套的初始化顺序解析

#include <iostream>
using namespace std;

class B {
public:
    // B的默认构造（无参）
    B() {
        cout << "B的默认构造函数执行" << endl;
    }
    // B的有参构造
    B(int num) : m_num(num) {
        cout << "B的有参构造执行，num=" << m_num << endl;
    }
private:
    int m_num;
};

class A {
public:
    // 场景1.1：未显式初始化B → 自动调用B的默认构造
    A() { 
        cout << "A的构造函数体执行（B已初始化）" << endl;
    }

    // 场景1.2：显式在初始化列表初始化B（调用有参构造）
    A(int b_num) : m_b(b_num) { // 初始化列表：先构造m_b → 再执行函数体
        cout << "A的有参构造函数体执行" << endl;
    }

private:
    B m_b; // A包含B的普通对象成员
};

int main() {
    cout << "==== 创建A的无参对象 ====" << endl;
    A a1; // 输出：B的默认构造 → A的构造函数体

    cout << "\n==== 创建A的有参对象 ====" << endl;
    A a2(10); // 输出：B的有参构造(10) → A的有参构造函数体
    return 0;
}

==== 创建A的无参对象 ====
B的默认构造函数执行
A的构造函数体执行（B已初始化）

==== 创建A的有参对象 ====
B的有参构造执行，num=10
A的有参构造函数体执行

class B {
public:
    B() { cout << "B的默认构造执行" << endl; }
    B(int num) : m_num(num) { cout << "B的有参构造执行，num=" << num << endl; }
    ~B() { cout << "B的析构执行" << endl; }
private:
    int m_num;
};

class A {
public:
    // 场景2.1：初始化列表给指针赋值（创建B对象）
    A() : m_b_ptr(new B()) { 
        cout << "A的构造函数体执行（B对象已通过指针创建）" << endl;
    }

    // 场景2.2：构造函数体中创建B对象
    A(int b_num) {
        m_b_ptr = new B(b_num); // 指针默认是nullptr，此处手动创建B
        cout << "A的有参构造函数体执行" << endl;
    }

    // 必须手动析构B对象，避免内存泄漏
    ~A() {
        delete m_b_ptr;
        cout << "A的析构执行" << endl;
    }

private:
    B* m_b_ptr; // A包含B的指针成员
};

int main() {
    A a1; // 输出：B的默认构造 → A的构造函数体
    A a2(20); // 输出：B的有参构造(20) → A的有参构造函数体
    return 0;
}

B的默认构造执行
A的构造函数体执行（B对象已通过指针创建）
B的有参构造执行，num=20
A的有参构造函数体执行
A的析构执行
B的析构执行
A的析构执行
B的析构执行

class B {
public:
    B(int num) : m_num(num) { cout << "B的有参构造执行，num=" << num << endl; }
private:
    int m_num;
};

class A {
public:
    // 场景3：引用成员必须在初始化列表绑定
    A(B& b_obj) : m_b_ref(b_obj) { // 绑定外部传入的B对象
        cout << "A的构造函数体执行（引用已绑定）" << endl;
    }

private:
    B& m_b_ref; // A包含B的引用成员
};

int main() {
    B b(30); // 先创建B对象
    A a(b);  // A的引用成员绑定到b
    return 0;
}

B的有参构造执行，num=30
A的构造函数体执行（引用已绑定）

class A {
public:
    // 初始化列表书写顺序：b2 → b1，但实际执行顺序是b1 → b2（声明顺序）
    A() : m_b2(20), m_b1(10) { }
private:
    B m_b1; // 先初始化
    B m_b2; // 后初始化
};

class B {
public:
    B(int num) {} // 无默认构造
};

class A {
public:
    A() {
        m_b = B(10); // 编译报错！m_b已在初始化列表阶段尝试调用默认构造（不存在）
    }
private:
    B m_b;
};

class A {
public:
    A() {} // 编译报错！引用成员m_b_ref未初始化
private:
    B& m_b_ref;
};