构造函数与析构函数执行顺序 ​

面试考点 ​

这道题考察你对 C++ 对象生命周期的理解。面试官可能给一段包含继承和成员对象的代码,让你说出构造和析构的执行顺序。关键是记住:构造从基类到派生类,析构完全相反。

核心规则 ​

构造顺序(固定不变,与初始化列表顺序无关):

  1. 虚基类构造(如果有,由最终派生类负责)
  2. 直接基类构造(按继承声明顺序,从左到右)
  3. 成员变量构造(按类中声明顺序,不是初始化列表顺序)
  4. 构造函数体执行

析构顺序:完全相反。

基本示例 ​

cpp
#include <iostream>
#include <string>

// ============================
// 示例1:单继承的构造/析构顺序
// ============================

class Base {
public:
    Base() { std::cout << "Base 构造" << std::endl; }
    ~Base() { std::cout << "Base 析构" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "Derived 构造" << std::endl; }
    ~Derived() { std::cout << "Derived 析构" << std::endl; }
};

class GrandChild : public Derived {
public:
    GrandChild() { std::cout << "GrandChild 构造" << std::endl; }
    ~GrandChild() { std::cout << "GrandChild 析构" << std::endl; }
};

void single_inheritance_demo() {
    GrandChild g;
    // 构造顺序:Base -> Derived -> GrandChild
    // 析构顺序:GrandChild -> Derived -> Base
}

// ============================
// 示例2:成员对象的构造顺序
// ============================

class Engine {
public:
    Engine() { std::cout << "  Engine 构造" << std::endl; }
    ~Engine() { std::cout << "  Engine 析构" << std::endl; }
};

class Wheel {
public:
    Wheel() { std::cout << "  Wheel 构造" << std::endl; }
    ~Wheel() { std::cout << "  Wheel 析构" << std::endl; }
};

class Car {
    Engine engine_;   // 先声明的先构造
    Wheel wheel_;     // 后声明的后构造
public:
    // 即使初始化列表写成 wheel_ 在前,实际顺序仍按声明顺序
    Car() : wheel_(), engine_() {
        std::cout << "  Car 构造" << std::endl;
    }
    ~Car() {
        std::cout << "  Car 析构" << std::endl;
    }
    // 构造顺序:Engine -> Wheel -> Car 函数体
    // 析构顺序:Car 函数体 -> Wheel -> Engine
};

void member_order_demo() {
    Car c;
}

// ============================
// 示例3:继承 + 成员对象
// ============================

class Logger {
    std::string tag_;
public:
    Logger(const std::string& tag) : tag_(tag) {
        std::cout << "    Logger(" << tag_ << ") 构造" << std::endl;
    }
    ~Logger() {
        std::cout << "    Logger(" << tag_ << ") 析构" << std::endl;
    }
};

class Animal {
    Logger log_{"Animal"};  // 成员对象
public:
    Animal() { std::cout << "    Animal 构造体" << std::endl; }
    ~Animal() { std::cout << "    Animal 析构体" << std::endl; }
};

class Dog : public Animal {
    Logger log_{"Dog"};     // 派生类的成员对象
public:
    Dog() { std::cout << "    Dog 构造体" << std::endl; }
    ~Dog() { std::cout << "    Dog 析构体" << std::endl; }
};

void inheritance_member_demo() {
    Dog d;
    // 构造顺序:
    // 1. Animal 的成员 Logger("Animal")
    // 2. Animal 构造体
    // 3. Dog 的成员 Logger("Dog")
    // 4. Dog 构造体

    // 析构顺序:完全相反
    // 1. Dog 析构体
    // 2. Dog 的成员 Logger("Dog")
    // 3. Animal 析构体
    // 4. Animal 的成员 Logger("Animal")
}

// ============================
// 示例4:多重继承
// ============================

class A {
public:
    A() { std::cout << "A 构造" << std::endl; }
    ~A() { std::cout << "A 析构" << std::endl; }
};

class B {
public:
    B() { std::cout << "B 构造" << std::endl; }
    ~B() { std::cout << "B 析构" << std::endl; }
};

class C : public A, public B {  // A 在左,B 在右
public:
    C() { std::cout << "C 构造" << std::endl; }
    ~C() { std::cout << "C 析构" << std::endl; }
};

void multiple_inheritance_demo() {
    C c;
    // 构造顺序:A -> B -> C(按继承列表从左到右)
    // 析构顺序:C -> B -> A
}

// ============================
// 示例5:虚继承(菱形继承)
// ============================

class VBase {
public:
    VBase() { std::cout << "VBase 构造" << std::endl; }
    ~VBase() { std::cout << "VBase 析构" << std::endl; }
};

class Left : virtual public VBase {
public:
    Left() { std::cout << "Left 构造" << std::endl; }
    ~Left() { std::cout << "Left 析构" << std::endl; }
};

class Right : virtual public VBase {
public:
    Right() { std::cout << "Right 构造" << std::endl; }
    ~Right() { std::cout << "Right 析构" << std::endl; }
};

class Diamond : public Left, public Right {
public:
    Diamond() { std::cout << "Diamond 构造" << std::endl; }
    ~Diamond() { std::cout << "Diamond 析构" << std::endl; }
};

void diamond_demo() {
    Diamond d;
    // 构造顺序:
    // 1. VBase(虚基类最先,只构造一次)
    // 2. Left(第一个直接基类)
    // 3. Right(第二个直接基类)
    // 4. Diamond

    // 析构顺序:完全相反
}

int main() {
    std::cout << "=== 单继承 ===" << std::endl;
    single_inheritance_demo();

    std::cout << "\n=== 成员对象 ===" << std::endl;
    member_order_demo();

    std::cout << "\n=== 继承+成员 ===" << std::endl;
    inheritance_member_demo();

    std::cout << "\n=== 多重继承 ===" << std::endl;
    multiple_inheritance_demo();

    std::cout << "\n=== 菱形继承 ===" << std::endl;
    diamond_demo();

    return 0;
}

构造/析构顺序速查表 ​

阶段构造顺序析构顺序
虚基类最先最后
直接基类继承列表从左到右从右到左
成员变量声明顺序声明逆序
构造/析构函数体最后最先

常见问题 ​

初始化列表的顺序会影响构造顺序吗?

不会。成员的构造顺序完全由类中声明顺序决定,和初始化列表的书写顺序无关。编译器通常会对不匹配的情况给出警告(-Wreorder)。

构造函数中调用虚函数会怎样?

调用的是当前正在构造的类的版本,不会表现多态行为。因为基类构造时派生类还没构造,vptr 指向基类的 vtable。

成员变量之间可以相互依赖初始化吗?

可以,但必须注意声明顺序。如果成员 b 的初始化依赖成员 a,那么 a 必须在 b 之前声明,否则 a 还没初始化就被使用了。

适用场景 ​

  • 资源管理类的设计(确保先获取后释放)
  • 日志系统初始化顺序
  • 数据库连接池的构造/销毁
  • 多层继承体系中的初始化

注意事项 ​

  • 成员构造顺序由声明顺序决定,不是初始化列表顺序
  • 析构顺序是构造顺序的严格逆序
  • 虚基类由最终派生类负责构造,且只构造一次
  • 基类构造函数中不要调用虚函数期望多态行为
  • 全局/静态对象的构造顺序在不同翻译单元间是未定义的

总结 ​

C++ 的构造顺序是确定的:虚基类先、直接基类按声明顺序、成员变量按声明顺序、最后是构造函数体。析构顺序严格相反。初始化列表的书写顺序不影响实际构造顺序。面试中最常见的陷阱是:初始化列表顺序不等于构造顺序;基类构造函数中调用虚函数不会多态;成员间有依赖时必须注意声明顺序。