构造函数与析构函数执行顺序
面试考点
这道题考察你对 C++ 对象生命周期的理解。面试官可能给一段包含继承和成员对象的代码,让你说出构造和析构的执行顺序。关键是记住:构造从基类到派生类,析构完全相反。
核心规则
构造顺序(固定不变,与初始化列表顺序无关):
- 虚基类构造(如果有,由最终派生类负责)
- 直接基类构造(按继承声明顺序,从左到右)
- 成员变量构造(按类中声明顺序,不是初始化列表顺序)
- 构造函数体执行
析构顺序:完全相反。
基本示例
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++ 的构造顺序是确定的:虚基类先、直接基类按声明顺序、成员变量按声明顺序、最后是构造函数体。析构顺序严格相反。初始化列表的书写顺序不影响实际构造顺序。面试中最常见的陷阱是:初始化列表顺序不等于构造顺序;基类构造函数中调用虚函数不会多态;成员间有依赖时必须注意声明顺序。