C++笔记 继承关系中构造和析构顺序（面向对象）

在C++面向对象编程中，继承是实现代码复用和类层次设计的核心特性。当存在基类与派生类的继承关系时，构造函数和析构函数的调用顺序 有严格的规则------这不仅是面试高频考点，更是避免内存泄漏、保证对象正确初始化/清理的关键。核心结论先明确：构造顺序：基类 → 派生类；析构顺序：派生类 → 基类，即"先构造父，后构造子；先析构子，后析构父"。

一、核心原理：为什么是这个顺序？

构造函数的核心作用是初始化对象的成员变量，析构函数则是清理对象占用的资源（如动态内存、文件句柄等）。继承关系中，派生类会包含基类的所有成员（公有、保护、私有，私有成员仅基类可访问），因此必须遵循"先初始化基类，再初始化派生类"的逻辑------否则派生类使用基类成员时，基类还未初始化，会导致程序异常。

析构函数则相反：派生类的资源往往依赖于基类的资源，若先析构基类，派生类中依赖基类资源的部分会变成"野资源"，无法正常清理，进而导致内存泄漏。因此必须"先析构派生类，释放其独有资源，再析构基类，释放基类资源"。

简单记：构造"从父到子"，析构"从子到父"，本质是"依赖关系"决定顺序------派生类依赖基类，初始化先满足依赖，清理先释放依赖方。

二、基础案例：单继承下的构造与析构顺序

单继承（一个派生类只继承一个基类）是最常见的场景，我们通过代码演示顺序，结合输出结果直观理解。

1. 代码实现

#include <iostream>
using namespace std;

// 基类（父类）
class Base {
public:
    // 基类构造函数
    Base() {
        cout << "Base 构造函数调用" << endl;
    }
    // 基类析构函数
    ~Base() {
        cout << "Base 析构函数调用" << endl;
    }
};

// 派生类（子类），公有继承基类
class Derived : public Base {
public:
    // 派生类构造函数
    Derived() {
        cout << "Derived 构造函数调用" << endl;
    }
    // 派生类析构函数
    ~Derived() {
        cout << "Derived 析构函数调用" << endl;
    }
};

// 主函数测试
int main() {
    // 创建派生类对象
    Derived d;
    // 函数结束，对象自动销毁
    return 0;
}
}

2. 运行结果

Base 构造函数调用
Derived 构造函数调用
Derived 析构函数调用
Base 析构函数调用

3. 结果分析

当创建派生类对象d时，编译器会先自动调用基类Base的构造函数，完成基类部分的初始化；再调用派生类Derived的构造函数，完成派生类独有部分的初始化。

当主函数结束，对象d生命周期结束，编译器会先调用派生类的析构函数，清理派生类的资源；再调用基类的析构函数，清理基类的资源，完全符合"先父后子构造，先子后父析构"的规则。

三、进阶案例：多继承下的构造与析构顺序

多继承（一个派生类继承多个基类）时，构造顺序会新增一个规则：基类的构造顺序，由派生类继承时的"声明顺序"决定；析构顺序则与基类构造顺序相反，与派生类继承声明顺序也相反。

1. 代码实现

#include <iostream>
using namespace std;

// 基类1
class Base1 {
public:
    Base1() { cout << "Base1 构造函数调用" << endl; }
    ~Base1() { cout << "Base1 析构函数调用" << endl; }
};

// 基类2
class Base2 {
public:
    Base2() { cout << "Base2 构造函数调用" << endl; }
    ~Base2() { cout << "Base2 析构函数调用" << endl; }
};

// 基类3
class Base3 {
public:
    Base3() { cout << "Base3 构造函数调用" << endl; }
    ~Base3() { cout << "Base3 析构函数调用" << endl; }
};

// 派生类，继承顺序：Base2 → Base1 → Base3
class Derived : public Base2, public Base1, public Base3 {
public:
    Derived() { cout << "Derived 构造函数调用" << endl; }
    ~Derived() { cout << "Derived 析构函数调用" &lt;&lt; endl; }
};

int main() {
    Derived d;
    return 0;
}
}

2. 运行结果

Base2 构造函数调用
Base1 构造函数调用
Base3 构造函数调用
Derived 构造函数调用
Derived 析构函数调用
Base3 析构函数调用
Base1 析构函数调用
Base2 析构函数调用

3. 关键结论

1. 多继承的基类构造顺序：严格按照派生类继承声明时的顺序（示例中继承顺序是Base2、Base1、Base3，因此构造顺序也是Base2→Base1→Base3），与基类的定义顺序无关。

2. 多继承的基类析构顺序：与基类构造顺序完全相反（示例中构造顺序Base2→Base1→Base3，析构顺序则是Base3→Base1→Base2）。

3. 无论单继承还是多继承，派生类的构造永远在所有基类构造之后，派生类的析构永远在所有基类析构之前。

四、特殊场景：含成员对象的继承构造/析构顺序

若派生类（或基类）中包含"成员对象"（即类的成员是另一个类的对象），则构造顺序会新增一层：先构造基类 → 再构造派生类的成员对象（按成员声明顺序） → 最后构造派生类本身 ；析构顺序则相反：先析构派生类 → 再析构派生类的成员对象（与成员声明顺序相反） → 最后析构基类。

1. 代码实现

#include <iostream>
using namespace std;

// 成员对象所属的类
class Member {
public:
    Member() { cout << "Member 构造函数调用" << endl; }
    ~Member() { cout << "Member 析构函数调用" << endl; }
};

// 基类
class Base {
public:
    Base() { cout << "Base 构造函数调用" << endl; }
    ~Base() { cout << "Base 析构函数调用" << endl; }
};

// 派生类：继承Base，包含Member类型的成员对象
class Derived : public Base {
private:
    // 成员对象（声明顺序：m1在前，m2在后）
    Member m1;
    Member m2;
public:
    Derived() { cout << "Derived 构造函数调用" << endl; }
    ~Derived() { cout << "Derived 析构函数调用" << endl; }
};

int main() {
    Derived d;
    return 0;
}
}

2. 运行结果

Base 构造函数调用
Member 构造函数调用  // m1的构造
Member 构造函数调用  // m2的构造
Derived 构造函数调用
Derived 析构函数调用
Member 析构函数调用  // m2的析构
Member 析构函数调用  // m1的析构
Base 析构函数调用

五、关键注意事项（避坑重点）

1. 析构函数的"虚函数"问题（多态场景）

当用基类指针指向派生类对象，且基类析构函数不是虚函数时，销毁对象时只会调用基类的析构函数，派生类的析构函数不会被调用，导致派生类的资源泄漏！

解决方案：将基类的析构函数声明为虚函数（virtual ~Base()），此时会根据对象的实际类型（派生类）调用对应的析构函数，保证析构顺序正确。

// 正确写法（基类析构为虚函数）
class Base {
public:
    virtual ~Base() { // 虚析构函数
        cout << "Base 析构函数调用" << endl;
    }
};

2. 构造函数的初始化列表（基类与成员对象）

若基类或成员对象没有默认构造函数（只有带参构造），必须在派生类的初始化列表 中显式调用基类和成员对象的带参构造，且顺序为：基类构造 → 成员对象构造（与初始化列表中的顺序无关，只与声明顺序有关）。

// 示例：基类和成员对象均为带参构造
class Base {
public:
    Base(int x) { cout << "Base 带参构造（x=" << x << "）" << endl; }
};

class Member {
public:
    Member(int y) { cout << "Member 带参构造（y=" << y << "）" << endl; }
};

class Derived : public Base {
private:
    Member m;
public:
    // 初始化列表：显式调用基类和成员对象的带参构造
    Derived() : Base(10), m(20) {
        cout << "Derived 构造函数" << endl;
    }
};

3. 不要在构造/析构函数中调用虚函数

构造函数执行时，对象的虚函数表尚未完全初始化，此时调用虚函数，只会调用当前类（基类/派生类）的虚函数，无法实现多态；析构函数执行时，对象的虚函数表已开始销毁，同样无法正确调用派生类的虚函数，容易导致逻辑错误。

六、总结（必背核心）

无论何种继承场景，构造与析构顺序的核心逻辑不变，可分3类场景记忆：

1. 单继承（无成员对象）

构造：基类 → 派生类；析构：派生类 → 基类

2. 多继承（无成员对象）

构造：基类（按派生类继承声明顺序） → 派生类；析构：派生类 → 基类（按构造顺序相反）

3. 含成员对象的继承

构造：基类 → 派生类成员对象（按成员声明顺序） → 派生类；

析构：派生类 → 派生类成员对象（按声明顺序相反） → 基类

4. 关键补充

基类析构函数建议声明为虚函数（多态场景必做），避免资源泄漏；

初始化列表中，基类和成员对象的构造顺序，由声明顺序决定，与列表顺序无关；

核心原则：先初始化依赖的部分，后初始化自身；先清理自身，后清理依赖的部分。

掌握继承关系中的构造和析构顺序，是写出安全、健壮C++面向对象代码的基础，也是区分基础薄弱与扎实的关键考点，务必结合代码多练习、多验证。