在 C++ 中，对象的生命周期是怎样的？

一、对象生命周期的核心定义

对象的生命周期 = 创建阶段（内存分配 → 构造函数调用） + 存活阶段（可访问、可操作） + 销毁阶段（析构函数调用 → 内存释放）。
不同存储位置的对象，生命周期的触发时机、管理方式完全不同，这是理解的关键。

二、不同类型对象的生命周期详解

1. 栈对象（最常用）

• 创建时机：进入对象所在的作用域时（比如函数内、循环内、if分支内），系统自动在栈上分配内存，并调用构造函数初始化。
• 销毁时机：离开该作用域时（作用域结束，比如函数执行完毕、循环/if结束），系统自动调用析构函数清理资源，再释放栈内存。
• 核心特点：自动管理，无需手动干预，生命周期严格绑定作用域。

示例代码：

#include <iostream>
using namespace std;

class Test {
public:
    Test() { cout << "Test对象创建（构造函数）" << endl; }
    ~Test() { cout << "Test对象销毁（析构函数）" << endl; }
};

void func() {
    // 进入func作用域，创建栈对象t1
    Test t1;  
    if (true) {
        // 进入if分支作用域，创建栈对象t2
        Test t2;  
    }
    // 离开if分支，t2先销毁
    cout << "func函数执行中..." << endl;
}
// 离开func作用域，t1销毁

int main() {
    func();
    cout << "main函数执行中..." << endl;
    return 0;
}

输出结果（按执行顺序）：

Test对象创建（构造函数）  // t1创建
Test对象创建（构造函数）  // t2创建
Test对象销毁（析构函数）  // t2销毁（离开if作用域）
func函数执行中...
Test对象销毁（析构函数）  // t1销毁（离开func作用域）
main函数执行中...

2. 堆对象（手动管理）

• 创建时机：显式调用new关键字时，系统在堆上分配内存，然后调用构造函数初始化，返回对象指针。
• 销毁时机：必须显式调用delete关键字时，先调用析构函数清理资源，再释放堆内存；若未调用delete，会导致内存泄漏（对象一直占用堆内存，程序结束前不会释放）。
• 核心特点：生命周期由程序员手动控制，与作用域无关。

示例代码：

#include <iostream>
using namespace std;

class Test {
public:
    Test() { cout << "Test对象创建（构造函数）" << endl; }
    ~Test() { cout << "Test对象销毁（析构函数）" << endl; }
};

void func() {
    // 堆对象创建：new触发构造函数
    Test* ptr = new Test();  
    cout << "func函数执行中..." << endl;
    
    // 手动调用delete，堆对象销毁（注释这行则内存泄漏）
    delete ptr;  
}

int main() {
    func();
    cout << "main函数执行中..." << endl;
    return 0;
}

输出结果（未注释delete时）：

Test对象创建（构造函数）
func函数执行中...
Test对象销毁（析构函数）
main函数执行中...

注意：若注释delete ptr;，析构函数不会执行，堆内存泄漏，直到程序完全退出才会被操作系统回收（仅系统层面回收，程序内仍属于泄漏）。

3. 全局/静态对象

• 全局对象：定义在所有函数（包括main）之外的对象；
• 静态对象：用static关键字修饰的对象（比如函数内的static Test t;、类内的静态成员对象）。
• 创建时机：程序启动（main函数执行前），全局/静态区分配内存，调用构造函数初始化；
• 销毁时机：程序退出（main函数执行完毕后），调用析构函数清理资源，再释放内存。
• 核心特点：生命周期贯穿整个程序运行期，全局唯一（静态对象）。

示例代码：

#include <iostream>
using namespace std;

class Test {
public:
    Test(string name) : objName(name) { 
        cout << objName << " 创建（构造函数）" << endl; 
    }
    ~Test() { 
        cout << objName << " 销毁（析构函数）" << endl; 
    }
private:
    string objName;
};

// 全局对象：main执行前创建
Test globalTest("全局对象");

void func() {
    // 静态局部对象：第一次进入func时创建，程序退出时销毁
    static Test staticTest("静态局部对象");
    cout << "func函数执行中..." << endl;
}

int main() {
    cout << "main函数开始执行..." << endl;
    func();  // 第一次调用func，创建staticTest
    func();  // 第二次调用func，staticTest已存在，不再创建
    cout << "main函数执行完毕..." << endl;
    return 0;
}

输出结果（按执行顺序）：

全局对象 创建（构造函数）  // main执行前
main函数开始执行...
静态局部对象 创建（构造函数）  // 第一次调用func
func函数执行中...
func函数执行中...  // 第二次调用func，静态对象已存在
main函数执行完毕...
静态局部对象 销毁（析构函数）  // 程序退出前
全局对象 销毁（析构函数）     // 程序退出前

三、特殊场景：临时对象的生命周期

临时对象是编译器自动创建的匿名对象（比如函数返回值、表达式临时结果），生命周期极短：

• 创建时机：表达式求值时（比如Test()直接创建匿名对象）；
• 销毁时机：当前表达式执行完毕后立即销毁（除非被绑定到const引用，生命周期会延长至引用失效）。

示例代码：

#include <iostream>
using namespace std;

class Test {
public:
    Test() { cout << "临时对象创建" << endl; }
    ~Test() { cout << "临时对象销毁" << endl; }
};

int main() {
    cout << "开始创建临时对象..." << endl;
    Test();  // 创建匿名临时对象
    cout << "临时对象已销毁" << endl;
    return 0;
}

输出结果：

开始创建临时对象...
临时对象创建
临时对象销毁
临时对象已销毁

总结

1. 栈对象：生命周期绑定作用域，进入创建、离开销毁，系统自动管理；
2. 堆对象：生命周期由new/delete控制，手动管理，漏写delete会导致内存泄漏；
3. 全局/静态对象：生命周期贯穿整个程序，main执行前创建、程序退出时销毁；
4. 临时对象：表达式执行时创建，执行完毕销毁（const引用可延长其生命周期）。