跳到主要内容

C++ 继承中的析构函数

在C++面向对象编程中，析构函数是对象生命周期结束时自动调用的特殊成员函数，用于释放资源并执行必要的清理工作。当我们涉及到继承关系时，析构函数的行为变得尤为重要，不正确的使用可能导致内存泄漏和资源未释放等严重问题。

析构函数基础回顾​

在深入继承中的析构函数之前，让我们先简单回顾一下析构函数的基本概念：

  • 析构函数名称与类名相同，前面加上波浪号（~）
  • 不接受参数，也没有返回值
  • 每个类只能有一个析构函数
  • 如果未显式定义，编译器会自动生成默认析构函数
cpp
class MyClass {
public:
    MyClass() {
        // 构造函数
        std::cout << "构造函数被调用" << std::endl;
    }
    
    ~MyClass() {
        // 析构函数
        std::cout << "析构函数被调用" << std::endl;
    }
};

int main() {
    {
        MyClass obj; // 构造函数被调用
    } // 离开作用域，析构函数被调用
    
    return 0;
}

// 输出:
// 构造函数被调用
// 析构函数被调用

继承中析构函数的调用顺序​

当派生类对象被销毁时，析构函数的调用顺序与构造函数的调用顺序相反：

  1. 首先调用派生类的析构函数
  2. 然后调用基类的析构函数

这种顺序符合直觉，因为派生类的析构函数负责清理派生类特有的资源，而基类的析构函数负责清理基类的资源。

cpp
class Base {
public:
    Base() { std::cout << "Base 构造函数" << std::endl; }
    ~Base() { std::cout << "Base 析构函数" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "Derived 构造函数" << std::endl; }
    ~Derived() { std::cout << "Derived 析构函数" << std::endl; }
};

int main() {
    {
        Derived d;
    }
    return 0;
}

// 输出:
// Base 构造函数
// Derived 构造函数
// Derived 析构函数
// Base 析构函数

虚析构函数的重要性​

在继承中，虚析构函数是一个至关重要的概念。当我们通过基类指针删除一个派生类对象时，如果基类的析构函数不是虚函数，那么只会调用基类的析构函数，而不会调用派生类的析构函数。

这会导致严重的内存泄漏，因为派生类分配的资源没有被正确释放。

不使用虚析构函数的问题​

cpp
class Base {
public:
    Base() { std::cout << "Base 构造函数" << std::endl; }
    ~Base() { std::cout << "Base 析构函数" << std::endl; }
};

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

int main() {
    Base* b = new Derived(); // 通过基类指针创建派生类对象
    delete b; // 只会调用Base的析构函数，导致内存泄漏！
    
    return 0;
}

// 输出:
// Base 构造函数
// Derived 构造函数
// Base 析构函数

注意到上面的代码中，Derived的析构函数没有被调用，这意味着data指向的内存没有被释放，造成了内存泄漏！

使用虚析构函数的解决方案​

cpp
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() {
        std::cout << "Derived 构造函数" << std::endl;
        data = new int[10];
    }
    
    ~Derived() override {
        std::cout << "Derived 析构函数" << std::endl;
        delete[] data;
    }
};

int main() {
    Base* b = new Derived();
    delete b; // 现在会正确调用Derived的析构函数
    
    return 0;
}

// 输出:
// Base 构造函数
// Derived 构造函数
// Derived 析构函数
// Base 析构函数
提示

如果你的类设计为基类或可能被继承，几乎总是应该将析构函数声明为虚函数！

纯虚析构函数​

有时候，我们希望一个类是抽象类（不能实例化），但又没有适合设为纯虚函数的方法。这种情况下，我们可以使用纯虚析构函数：

cpp
class AbstractBase {
public:
    virtual ~AbstractBase() = 0; // 纯虚析构函数
};

// 纯虚析构函数必须有定义
AbstractBase::~AbstractBase() {
    std::cout << "AbstractBase 析构函数" << std::endl;
}

class Concrete : public AbstractBase {
public:
    ~Concrete() override {
        std::cout << "Concrete 析构函数" << std::endl;
    }
};

int main() {
    // AbstractBase ab; // 错误：不能创建抽象类的对象
    AbstractBase* p = new Concrete();
    delete p; // 正确调用析构函数链
    
    return 0;
}

// 输出:
// Concrete 析构函数
// AbstractBase 析构函数
警告

纯虚析构函数必须有一个实现，这与其他纯虚函数不同。这是因为即使在派生类中重写了析构函数，基类的析构函数仍然会被调用。

继承中析构函数的最佳实践​

  1. 基类析构函数应为虚函数：如果你的类将作为基类，请将其析构函数声明为虚函数。

  2. 使用 override 关键字：在C++11及以后的标准中，使用override关键字可以明确表示你是在重写基类的虚函数。

  3. 遵循"Rule of Three/Five/Zero"：如果你需要自定义析构函数，那么通常也需要自定义拷贝构造函数和拷贝赋值运算符（Rule of Three）。在C++11后，还需要考虑移动构造函数和移动赋值运算符（Rule of Five）。

  4. 保持析构函数简单：析构函数应该专注于释放资源，避免复杂逻辑和可能抛出异常的操作。

  5. 考虑使用智能指针：使用std::unique_ptr和std::shared_ptr可以自动管理资源生命周期，减少手动内存管理的错误。

实际应用案例​

资源管理类层次结构​

以下是一个简单的资源管理类层次结构，展示了正确使用析构函数的方式：

cpp
class Resource {
public:
    virtual ~Resource() {
        std::cout << "资源基类释放" << std::endl;
    }
    
    virtual void use() = 0;
};

class FileResource : public Resource {
private:
    FILE* file;
    std::string filename;
    
public:
    FileResource(const std::string& name) : filename(name) {
        file = fopen(name.c_str(), "r");
        if (file) {
            std::cout << "文件 " << filename << " 已打开" << std::endl;
        } else {
            std::cout << "无法打开文件 " << filename << std::endl;
        }
    }
    
    ~FileResource() override {
        if (file) {
            fclose(file);
            std::cout << "文件 " << filename << " 已关闭" << std::endl;
        }
    }
    
    void use() override {
        if (file) {
            std::cout << "使用文件资源 " << filename << std::endl;
        }
    }
};

class NetworkResource : public Resource {
private:
    int connectionId;
    
public:
    NetworkResource() : connectionId(connectToNetwork()) {
        std::cout << "网络连接 #" << connectionId << " 已建立" << std::endl;
    }
    
    ~NetworkResource() override {
        disconnectFromNetwork(connectionId);
        std::cout << "网络连接 #" << connectionId << " 已关闭" << std::endl;
    }
    
    void use() override {
        std::cout << "使用网络资源 #" << connectionId << std::endl;
    }
    
private:
    int connectToNetwork() {
        // 模拟网络连接逻辑
        return rand() % 1000 + 1;
    }
    
    void disconnectFromNetwork(int id) {
        // 模拟网络断开逻辑
    }
};

void useResource(Resource* res) {
    res->use();
    // 不用手动释放，因为外部会处理
}

int main() {
    Resource* resources[] = {
        new FileResource("data.txt"),
        new NetworkResource()
    };
    
    for (auto res : resources) {
        useResource(res);
    }
    
    // 正确释放资源
    for (auto res : resources) {
        delete res; // 会调用适当的派生类析构函数
    }
    
    return 0;
}

在这个例子中：

  1. Resource是一个抽象基类，定义了资源的通用接口
  2. FileResource和NetworkResource是具体的资源类型
  3. 基类有虚析构函数，确保正确释放派生类资源
  4. 每个派生类在析构函数中释放自己特有的资源

现代C++方法：使用智能指针​

以下是使用智能指针重写的版本，可以自动管理对象生命周期：

cpp
#include <iostream>
#include <memory>
#include <vector>
#include <string>

class Resource {
public:
    virtual ~Resource() {
        std::cout << "资源基类释放" << std::endl;
    }
    
    virtual void use() = 0;
};

class FileResource : public Resource {
    // 与上例相同
};

class NetworkResource : public Resource {
    // 与上例相同
};

void useResource(const std::shared_ptr<Resource>& res) {
    res->use();
    // 不用手动释放，shared_ptr会自动处理
}

int main() {
    std::vector<std::shared_ptr<Resource>> resources;
    
    resources.push_back(std::make_shared<FileResource>("data.txt"));
    resources.push_back(std::make_shared<NetworkResource>());
    
    for (const auto& res : resources) {
        useResource(res);
    }
    
    // 不需要显式删除，智能指针会自动管理
    resources.clear();
    
    return 0;
}

使用智能指针后，无需手动调用delete，当resources向量被清空或超出作用域时，智能指针会自动调用适当的析构函数。

总结​

在C++继承中，正确使用析构函数对于资源管理至关重要：

  • 基类的析构函数应该声明为虚函数，以确保通过基类指针删除派生类对象时能正确调用派生类的析构函数。
  • 析构函数调用顺序是从派生类到基类的逆序，这符合构造的相反顺序。
  • 纯虚析构函数可以用来创建抽象基类，但必须提供实现。
  • 现代C++推荐使用智能指针来自动管理对象的生命周期，减少手动资源管理的错误。

遵循这些最佳实践，可以有效避免内存泄漏和资源泄漏问题，编写出更健壮的C++程序。

练习​

  1. 创建一个Shape基类和Circle、Rectangle派生类，确保通过Shape指针删除对象时能正确调用所有析构函数。

  2. 修改一个存在内存泄漏的代码示例（基类没有虚析构函数），使用虚析构函数修复问题。

  3. 实现一个简单的资源管理类层次结构，使用虚析构函数和智能指针确保资源正确释放。

  4. 尝试写一个带有纯虚析构函数的抽象类，并创建其派生类的实例。

  5. 分析一个复杂继承层次中的析构函数调用顺序，并验证你的分析结果。

参考资料