C++析构函数是类的一种特殊成员函数，没有返回值，函数名与类名相同且前面加波浪号，在对象被销毁时自动执行，主要作用是释放对象生命周期内申请的资源，比如动态内存、文件句柄、网络连接等。理解析构函数的执行规则和对象销毁机制，是编写健壮C++程序的基础。
析构函数的基本定义与特性
析构函数的声明格式为~类名()，不需要参数，也不能被重载，一个类只能有一个析构函数。如果用户没有显式定义析构函数，编译器会自动生成一个默认的析构函数，默认析构函数只会销毁对象的成员变量，不会释放成员变量指向的动态资源。
下面是一个自定义析构函数的示例：
#include <iostream>
class Demo {
public:
// 构造函数
Demo() {
std::cout << "Demo对象构造完成" << std::endl;
data = new int(10); // 动态申请内存
}
// 析构函数
~Demo() {
std::cout << "Demo对象开始销毁" << std::endl;
delete data; // 释放动态内存
data = nullptr;
}
private:
int* data;
};
析构函数的触发执行场景
析构函数的执行由对象销毁触发，不同存储类型的对象销毁时机不同，对应的析构函数执行场景也有差异：
栈对象的析构
栈对象存储在函数的栈帧中，当对象所在的作用域结束时，会自动调用析构函数销毁对象。比如函数内的局部变量，当函数执行结束返回时，局部对象的析构函数会被自动调用。
#include <iostream>
class Test {
public:
Test(int id) : id(id) {
std::cout << "Test对象" << id << "构造" << std::endl;
}
~Test() {
std::cout << "Test对象" << id << "析构" << std::endl;
}
private:
int id;
};
void func() {
Test t1(1); // 局部栈对象
if (true) {
Test t2(2); // 块内局部栈对象
} // t2的作用域结束，调用t2的析构函数
std::cout << "func函数执行末尾" << std::endl;
} // t1的作用域结束，调用t1的析构函数
int main() {
func();
return 0;
}
上述代码的输出结果为：
Test对象1构造 Test对象2构造 Test对象2析构 func函数执行末尾 Test对象1析构
堆对象的析构
堆对象通过new运算符在堆上分配内存，只有当调用delete运算符释放该对象时，才会触发析构函数执行。如果只new不delete，会造成内存泄漏，析构函数也不会被执行。
#include <iostream>
class HeapObj {
public:
HeapObj() {
std::cout << "堆对象构造" << std::endl;
}
~HeapObj() {
std::cout << "堆对象析构" << std::endl;
}
};
int main() {
HeapObj* obj = new HeapObj(); // 构造堆对象，不触发析构
delete obj; // 释放堆对象，触发析构函数执行
obj = nullptr;
return 0;
}
全局对象和静态局部对象的析构
全局对象在程序启动时构造，程序结束时销毁，析构函数在程序退出阶段执行。静态局部对象在第一次执行到定义语句时构造，程序结束时销毁，析构函数同样在程序退出时执行。
继承体系下的析构函数执行顺序
当类存在继承关系时，析构函数的执行顺序和构造函数相反：先执行派生类的析构函数，再执行基类的析构函数。如果基类析构函数没有声明为虚函数，通过基类指针指向派生类对象并删除该指针时，只会调用基类的析构函数，派生类的析构函数不会执行，会导致资源泄漏。
因此，如果类会被继承，基类的析构函数必须声明为虚函数。
#include <iostream>
// 基类，析构函数声明为虚函数
class Base {
public:
Base() {
std::cout << "基类构造" << std::endl;
}
virtual ~Base() {
std::cout << "基类析构" << std::endl;
}
};
// 派生类
class Derived : public Base {
public:
Derived() {
std::cout << "派生类构造" << std::endl;
}
~Derived() {
std::cout << "派生类析构" << std::endl;
}
};
int main() {
Base* obj = new Derived(); // 基类指针指向派生类对象
delete obj; // 会先调用派生类析构，再调用基类析构
obj = nullptr;
return 0;
}
上述代码的输出结果为：
基类构造 派生类构造 派生类析构 基类析构
数组对象的析构规则
如果是数组形式的对象，销毁时会从最后一个元素开始，依次向前调用每个元素的析构函数。对于堆上的对象数组，必须使用delete[]来释放，不能使用delete，否则只会调用第一个元素的析构函数，其余元素的析构函数不会执行，还会造成内存释放错误。
#include <iostream>
class ArrObj {
public:
ArrObj(int id) : id(id) {
std::cout << "ArrObj对象" << id << "构造" << std::endl;
}
~ArrObj() {
std::cout << "ArrObj对象" << id << "析构" << std::endl;
}
private:
int id;
};
int main() {
ArrObj* arr = new ArrObj[3]{1,2,3}; // 堆上对象数组
delete[] arr; // 正确释放，依次调用3、2、1的析构函数
// delete arr; // 错误用法，会导致未定义行为
return 0;
}
析构函数使用注意事项
- 析构函数不能声明为const、volatile或static，也不能有参数，不能重载。
- 如果类中存在动态申请的资源，必须显式定义析构函数来释放资源，避免内存泄漏。
- 基类如果需要被继承，析构函数必须声明为虚函数，保证通过基类指针删除派生类对象时能正确执行所有析构函数。
- 析构函数中不要抛出异常，否则如果在析构过程中抛出异常，可能导致程序终止或者资源泄漏。