C++类构造函数调用时机深度解析：从对象创建到内存布局

1次阅读

共计 2200 个字符，预计需要花费 6 分钟才能阅读完成。

构造函数是 C ++ 对象生命周期的起点，当我们在代码中声明一个对象时，编译器会默默完成以下动作：

分配内存（栈或堆）
初始化虚表指针（如果存在虚函数）
按顺序调用成员变量的构造函数
执行构造函数体内的代码

理解这个流程对掌握 C ++ 对象模型至关重要。举个简单例子：

class Demo {
public:
    Demo() { std::cout << "构造函数被调用 \n";}
    ~Demo() { std::cout << "析构函数被调用 \n";}
};

int main() {
    Demo d;  // 栈上对象
    Demo* p = new Demo();  // 堆上对象
    delete p;
    return 0;
}

输出结果会清晰展示构造 / 析构的配对调用。

构造时机：作用域开始时
内存管理：自动回收
特点：
最常用的对象创建方式
构造 / 析构调用确定性强
适合生命周期明确的小型对象

构造时机：显式调用 new 时
内存管理：需要手动 delete
典型场景：
对象生命周期需要动态控制
大内存对象避免栈溢出
多态对象存储

// 堆分配示例
class Resource {
public:
    Resource() { /* 获取资源 */}
    ~Resource() { /* 释放资源 */}
};

void process() {Resource* res = new Resource();
    // 使用资源...
    delete res;  // 必须显式释放
}

构造时机：程序启动时（main 之前）
析构时机：程序退出时（main 之后）
注意事项：
初始化顺序不确定（跨编译单元）
可能引发「静态初始化顺序问题」

当存在继承关系时，构造函数的调用遵循以下规则：

基类构造函数（从最顶层开始）
成员变量构造函数（声明顺序）
派生类构造函数

虚继承的情况会更复杂，需要保证虚基类只被初始化一次：

classDiagram
    direction BT
    class A
    class B
    class C
    class D

    A <|-- B : virtual
    A <|-- C : virtual
    B <|-- D
    C <|-- D

对应的构造顺序：A → B → C → D

代码示例：

class Base {
public:
    Base() { cout << "Base 构造 \n";}
};

class Member {
public:
    Member() { cout << "Member 构造 \n";}
};

class Derived : public Base {
    Member m;
public:
    Derived() { cout << "Derived 构造 \n";}
};

// 输出顺序：Base → Member → Derived

允许在已分配的内存上构造对象：

#include <new>

char buffer[sizeof(MyClass)];
MyClass* p = new (buffer) MyClass();  // 在 buffer 上构造
p->~MyClass();  // 需要显式析构

C++11 起支持构造函数之间的调用：

class Box {
    int width, height;
public:
    Box() : Box(10, 10) {}  // 委托给下面的构造函数
    Box(int w, int h) : width(w), height(h) {}};

class Base {
public:
    Base() { print(); }  // 危险！virtual void print() { cout << "Base";}
};

class Derived : public Base {
public:
    void print() override { cout << "Derived";}
};

// 实际输出 "Base"，因为此时 Derived 尚未构造完成

class Resource {
public:
    Resource() {ptr = new int[100];
        throw std::runtime_error("意外");  // 内存泄漏！}
    ~Resource() { delete[] ptr; }
private:
    int* ptr;
};

解决方案：使用智能指针管理资源。

class Clock {
    int hour, minute;
public:
    // 危险：实际初始化顺序是声明顺序（hour→minute）Clock(int m) : minute(m), hour(minute/60) {}};

标记不会抛出异常的构造函数为 noexcept

class Safe {
public:
    Safe() noexcept { /* ... */}
};

编译期常量使用 constexpr

class Point {
public:
    constexpr Point(int x, int y) : x(x), y(y) {}
private:
    int x, y;
};

移动构造替代深拷贝

class Buffer {
public:
    Buffer(Buffer&& other) noexcept 
        : ptr(other.ptr), size(other.size) {other.ptr = nullptr;  // 避免重复释放}
private:
    char* ptr;
    size_t size;
};