C++析构函数特征与使用指南

周末不加班

发布时间：2026-10-13| 2人浏览过

原创

析构函数用于在对象生命周期结束时自动清理资源，特别是动态分配的内存。本文将深入解析其命名、参数、调用时机等核心特征，并对比编译器默认生成与显式定义的差异，通过代码示例说明如何正确管理堆内存以防止泄漏。

析构函数的核心特征

析构函数与构造函数功能相反。需要明确的是，局部对象的销毁（如栈内存回收）由编译器自动完成，而析构函数的作用是配合对象的销毁，执行类内部特定资源的清理工作（如释放堆内存、关闭文件句柄等）。

C++析构函数具备以下显著特征：

命名规范：函数名由波浪号 ~ 加上类名组成。
签名限制：不接受任何参数，也没有返回值（甚至不能写 void）。
唯一性：一个类只能有一个析构函数。
自动生成：如果用户未显式定义，系统会自动生成一个默认的析构函数。
自动调用：当对象生命周期结束（如离开作用域、对象被删除）时，编译器自动调用析构函数。

第1步：理解内存管理的必要性

在C++中，如果使用 malloc 或 new 动态分配了内存，必须确保有对应的 free 或 delete 操作。手动管理极易因代码路径复杂导致遗漏，从而引发内存泄漏。析构函数提供了一种“自动释放”的机制。

下面以顺序表 SeqList 为例。首先看仅包含构造函数的情况，此时动态申请的内存未被释放：

typedef int DataType;
class SeqList
{
public:
	SeqList(int capacity = 10)
	{
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
private:
	int* _pData;
	size_t _size;
	size_t _capacity;
};

第2步：显式定义析构函数释放资源

为了自动释放堆空间，需要在类中添加析构函数。在析构函数中检查指针有效性，执行释放操作并将指针置空，防止悬垂指针。

typedef int DataType;
class SeqList
{
public:
	SeqList(int capacity = 10)
	{
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
		if (_pData)
		{
			free(_pData); // 释放堆上的空间
			_pData = NULL; // 将指针置为空，防止野指针
			_capacity = 0;
			_size = 0;
		}
	}
private:
	int* _pData;
	size_t _size;
	size_t _capacity;
};

编译器生成的默认析构函数行为

当用户未定义析构函数时，编译器会生成一个默认的析构函数。它的清理逻辑遵循“递归清理”原则：只处理自定义类型（Class/Struct）的成员变量，对内置类型（int, char, pointer等）不做特殊处理。

第3步：验证默认析构函数对自定义类型的调用

通过以下代码观察：Person 类包含自定义类型成员 _name (String) 和内置类型成员 _age (int)。创建 Person 对象后，析构时会先调用 Person 的析构，随后自动调用成员 _name 的析构函数，而 _age 直接销毁。

class String
{
public:
	String(const char* str = "songxin")
	{
		cout << "String(const char* str = \"songxin\")" << endl;
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
		_str = nullptr;
	}
private:
	char* _str;
};
class Person
{
public:
	Person()
		:
		_age(20),
		_name()
	{
		cout << "Person()" << endl;
	}
	
private:
	String _name;
	int _age;
};
int main()
{
	Person p;
	return 0;
}

总结编译器默认析构函数的行为：

内置类型不处理：直接丢弃，依赖操作系统回收栈内存或忽略堆内存（后者危险）。
自定义类型成员调用析构：确保深层嵌套的对象资源也能得到清理。

关键风险：含指针成员时的内存泄漏

虽然内置类型通常无需处理，但有一个致命例外：指向堆内存的指针。

指针本身是内置类型，编译器默认析构函数不会释放它指向的空间。如果类成员包含指针且管理着堆内存，必须显式定义析构函数，否则必然导致内存泄漏。

第4步：显式定义析构函数处理指针成员

以下 Stack 类使用 new 分配内存。若依靠默认析构函数，_p 指向的数组将永远不会被释放。因此必须手动实现析构函数，使用 delete[] 释放数组内存。

class Stack
{
public:
	Stack(int capacity = 4)
		:
		_size(0),
		_capacity(capacity),
		_p(new int[_capacity])//使用new去申请内存
	{
		cout << "Stack(int capacity = 4)" << endl;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		if (_p)
		{
			delete[](_p);//释放内存
            _p = nullptr;
		}
		_size = _capacity = 0;
	}
private:	
	int _capacity;
	int _size;
	int* _p;
};
int main()
{
	Stack s;
	return 0;//程序结束，调用s的析构函数
}