C++ 析构函数

在C++面向对象编程中，析构函数是与构造函数相对应的特殊成员函数，负责在对象生命周期结束时进行清理工作。它是资源管理和防止内存泄漏的关键。

什么是析构函数？

析构函数是一个特殊的成员函数，当对象被销毁时自动调用。它的主要职责是释放对象在生命周期内分配的资源，如动态内存、打开的文件、数据库连接等。

析构函数的特点

函数名与类名相同，但前面加上波浪号（~）
没有返回值（包括void）
不能有参数
一个类只能有一个析构函数（不能重载）
如果没有定义，编译器会提供一个默认析构函数

析构函数的语法

cpp
class 类名 {
public:
    // 构造函数
    类名() {
        // 初始化代码
    }
    
    // 析构函数
    ~类名() {
        // 清理代码
    }
};

析构函数的调用时机

析构函数在以下情况下被调用：

局部对象（栈对象）离开其作用域时
通过delete删除动态分配（堆）对象时
程序结束时，全局或静态对象被销毁
临时对象完成表达式求值时

让我们通过一个例子来观察析构函数的调用时机：

cpp
#include <iostream>

class Example {
private:
    int id;
    
public:
    Example(int x) : id(x) {
        std::cout << "构造函数被调用，ID: " << id << std::endl;
    }
    
    ~Example() {
        std::cout << "析构函数被调用，ID: " << id << std::endl;
    }
};

void localObjectDemo() {
    std::cout << "函数开始执行" << std::endl;
    Example e1(1);  // 局部对象
    std::cout << "函数即将结束" << std::endl;
}  // e1在这里被销毁，析构函数被调用

int main() {
    std::cout << "程序开始执行" << std::endl;
    
    // 堆对象示例
    Example* e2 = new Example(2);
    
    // 调用局部对象函数
    localObjectDemo();
    
    std::cout << "准备删除堆对象" << std::endl;
    delete e2;  // 析构函数被调用
    
    std::cout << "创建局部对象" << std::endl;
    {  // 创建新的作用域
        Example e3(3);
        std::cout << "局部作用域即将结束" << std::endl;
    }  // e3在这里被销毁，析构函数被调用
    
    std::cout << "程序结束" << std::endl;
    return 0;
}

输出：

程序开始执行
构造函数被调用，ID: 2
函数开始执行
构造函数被调用，ID: 1
函数即将结束
析构函数被调用，ID: 1
准备删除堆对象
析构函数被调用，ID: 2
创建局部对象
构造函数被调用，ID: 3
局部作用域即将结束
析构函数被调用，ID: 3
程序结束

备注

注意观察析构函数的调用顺序：对象的销毁顺序与创建顺序相反。这符合栈的后进先出(LIFO)原则。

析构函数与资源管理

析构函数最重要的用途是释放在构造函数或对象生命周期中分配的资源。这是实现C++中RAII（资源获取即初始化）设计模式的基础。

示例：内存管理

cpp
#include <iostream>

class DynamicArray {
private:
    int* array;
    int size;
    
public:
    // 构造函数分配内存
    DynamicArray(int s) : size(s) {
        std::cout << "分配大小为 " << size << " 的数组" << std::endl;
        array = new int[size];  // 动态分配内存
    }
    
    // 析构函数释放内存
    ~DynamicArray() {
        std::cout << "释放数组内存" << std::endl;
        delete[] array;  // 释放动态分配的内存
    }
    
    void setValue(int index, int value) {
        if (index >= 0 && index < size) {
            array[index] = value;
        }
    }
    
    int getValue(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        }
        return -1;
    }
};

int main() {
    {
        DynamicArray arr(5);
        arr.setValue(0, 100);
        arr.setValue(4, 500);
        
        std::cout << "arr[0] = " << arr.getValue(0) << std::endl;
        std::cout << "arr[4] = " << arr.getValue(4) << std::endl;
    }  // arr在这里被销毁，析构函数自动释放内存
    
    std::cout << "程序继续执行..." << std::endl;
    return 0;
}

输出：

分配大小为 5 的数组
arr[0] = 100
arr[4] = 500
释放数组内存
程序继续执行...

警告

如果没有在析构函数中释放内存，当对象被销毁时，分配的内存将无法访问，导致内存泄漏。

析构函数的常见应用场景

1. 释放动态分配的内存

如上例所示，最常见的用途是释放通过new分配的内存。

2. 关闭文件句柄

cpp
class FileHandler {
private:
    FILE* file;
    
public:
    FileHandler(const char* filename) {
        file = fopen(filename, "r");
    }
    
    ~FileHandler() {
        if (file) {
            fclose(file);  // 确保文件被关闭
            std::cout << "文件已关闭" << std::endl;
        }
    }
    
    // 文件操作方法...
};

3. 释放系统资源

cpp
class DatabaseConnection {
private:
    // 假设这是数据库连接句柄
    void* connection;
    
public:
    DatabaseConnection() {
        // 建立数据库连接
        connection = establishConnection();
        std::cout << "数据库连接已建立" << std::endl;
    }
    
    ~DatabaseConnection() {
        // 关闭数据库连接
        closeConnection(connection);
        std::cout << "数据库连接已关闭" << std::endl;
    }
    
    // 模拟建立连接的函数
    void* establishConnection() {
        // 实际应用中会有真正的连接代码
        return (void*)1;
    }
    
    // 模拟关闭连接的函数
    void closeConnection(void* conn) {
        // 实际应用中会有真正的断开连接代码
    }
};

虚析构函数

当我们使用多态并通过基类指针删除派生类对象时，需要将基类的析构函数声明为虚函数，否则派生类的析构函数不会被调用，导致资源泄漏。

cpp
#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base 构造函数" << std::endl;
    }
    
    // 不使用virtual关键字
    ~Base() {
        std::cout << "Base 析构函数" << std::endl;
    }
};

class Derived : public Base {
private:
    int* data;
    
public:
    Derived() : Base() {
        std::cout << "Derived 构造函数" << std::endl;
        data = new int[10];  // 分配内存
    }
    
    ~Derived() {
        std::cout << "Derived 析构函数" << std::endl;
        delete[] data;  // 释放内存
    }
};

int main() {
    std::cout << "使用基类指针:" << std::endl;
    Base* ptr = new Derived();
    delete ptr;  // 只会调用Base的析构函数，不会调用Derived的析构函数！
    
    std::cout << "\n使用派生类指针:" << std::endl;
    Derived* dptr = new Derived();
    delete dptr;  // 正确调用两个析构函数
    
    return 0;
}

输出：

使用基类指针:
Base 构造函数
Derived 构造函数
Base 析构函数

使用派生类指针:
Base 构造函数
Derived 构造函数
Derived 析构函数
Base 析构函数

注意

注意第一个示例中，Derived的析构函数没有被调用，这会导致内存泄漏！

正确的做法是在基类中使用虚析构函数：

cpp
class Base {
public:
    Base() {
        std::cout << "Base 构造函数" << std::endl;
    }
    
    // 使用virtual关键字声明虚析构函数
    virtual ~Base() {
        std::cout << "Base 析构函数" << std::endl;
    }
};

现在，即使通过基类指针删除派生类对象，所有析构函数也会被正确调用。

实际应用案例：智能指针实现

析构函数在实现C++智能指针等资源管理类时非常重要。以下是一个简化的智能指针实现：

cpp
#include <iostream>

template<typename T>
class SmartPointer {
private:
    T* ptr;
    
public:
    // 构造函数获取资源
    SmartPointer(T* p = nullptr) : ptr(p) {
        std::cout << "SmartPointer 构造函数" << std::endl;
    }
    
    // 析构函数释放资源
    ~SmartPointer() {
        std::cout << "SmartPointer 析构函数" << std::endl;
        if (ptr) {
            delete ptr;
            ptr = nullptr;
        }
    }
    
    // 重载->操作符
    T* operator->() { return ptr; }
    
    // 重载*操作符
    T& operator*() { return *ptr; }
};

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数" << std::endl; }
    
    void display() {
        std::cout << "Hello from MyClass" << std::endl;
    }
};

int main() {
    // 传统方式：需要手动delete
    std::cout << "传统指针：" << std::endl;
    MyClass* rawPtr = new MyClass();
    rawPtr->display();
    delete rawPtr;  // 必须记得删除
    
    std::cout << "\n智能指针：" << std::endl;
    // 使用智能指针：自动管理内存
    {
        SmartPointer<MyClass> smartPtr(new MyClass());
        smartPtr->display();
        // 无需delete，离开作用域时自动调用析构函数
    }
    
    std::cout << "程序结束" << std::endl;
    return 0;
}

输出：

传统指针：
MyClass 构造函数
Hello from MyClass
MyClass 析构函数

智能指针：
SmartPointer 构造函数
MyClass 构造函数
Hello from MyClass
SmartPointer 析构函数
MyClass 析构函数
程序结束

析构函数的最佳实践

保持析构函数简单：应该只专注于资源释放，避免复杂的逻辑和可能抛出异常的操作。
基类析构函数应该是虚函数：当你的类用作基类时，声明虚析构函数。
检查指针有效性：在删除指针前检查其是否为nullptr。
遵循RAII原则：在构造函数中获取资源，在析构函数中释放资源。
不要在析构函数中抛出异常：这可能导致程序崩溃。

cpp
// 不好的做法
~BadClass() {
    throw std::runtime_error("在析构函数中抛出异常");  // 不要这样做！
}

// 好的做法
~GoodClass() noexcept {
    try {
        // 可能会抛出异常的操作
    } catch (const std::exception& e) {
        // 处理异常
        std::cerr << "析构函数中捕获异常: " << e.what() << std::endl;
    }
}

总结

析构函数是C++面向对象编程中不可或缺的组成部分，它为我们提供了自动管理资源的能力：

析构函数在对象生命周期结束时自动调用
主要用于释放对象占用的资源（内存、文件、网络连接等）
基类中应使用虚析构函数以确保多态情况下派生类析构函数的正确调用
是实现RAII（资源获取即初始化）模式的基础
在智能指针等资源管理类中起着关键作用

通过正确使用析构函数，你可以避免内存泄漏和资源泄露，编写更安全、更健壮的C++程序。

练习

创建一个ResourceManager类，在构造函数中分配一个整数数组，在析构函数中释放它。
实现一个简单的文件包装类，能在构造时打开文件，在析构时自动关闭。
创建一个基类和派生类，尝试使用和不使用虚析构函数，观察差异。
实现一个锁包装类，在构造函数中获取锁，在析构函数中释放锁。

其他资源

C++ 标准库中的智能指针(std::unique_ptr, std::shared_ptr)是析构函数应用的绝佳示例
Scott Meyers的《Effective C++》中有关于析构函数的深入讨论
C++ Core Guidelines中关于资源管理的最佳实践

掌握析构函数对于编写高质量的C++代码至关重要，尤其是在需要管理资源的场景中。随着经验的积累，你会发现析构函数是C++语言强大资源管理能力的核心。

什么是析构函数？​

析构函数的特点​

析构函数的语法​

析构函数的调用时机​

析构函数与资源管理​

示例：内存管理​

析构函数的常见应用场景​

1. 释放动态分配的内存​

2. 关闭文件句柄​

3. 释放系统资源​

虚析构函数​

实际应用案例：智能指针实现​

析构函数的最佳实践​

总结​

练习​

其他资源​