纯虚函数，虚函数，析构函数

这些概念都是面向对象编程（OOP）中非常重要的核心思想，特别是在 C++ 中。我们逐一解释一下：

1. 虚函数 (Virtual Function)

定义：虚函数是一个在基类中声明并且可以在派生类中重写（覆盖）的方法。它的特点是支持 动态绑定（或称为运行时多态）。

• 如果一个函数在基类中声明为虚函数（使用 virtual 关键字），那么通过基类指针或引用调用该函数时，实际调用的函数是由对象的实际类型决定的，而不是指针或引用的类型。

• 虚函数可以在派生类中被重写（覆盖），如果没有被重写，则调用基类的实现。

class Animal {
public:
    virtual void makeSound() {  // 虚函数
        std::cout << "Animal makes a sound\n";
    }
};

class Dog : public Animal {
public:
    void makeSound() override {  // 重写虚函数
        std::cout << "Dog barks\n";
    }
};

int main() {
    Animal* animal = new Dog();
    animal->makeSound();  // 输出: Dog barks
    delete animal;
}

• 在上面的代码中，makeSound() 在基类 Animal 中被声明为虚函数。通过基类指针 animal 调用 makeSound() 时，实际上调用的是 Dog 类中的实现，表现出多态特性。

2. 纯虚函数 (Pure Virtual Function)

定义：纯虚函数是一个在基类中声明但没有实现的虚函数，表示该函数在基类中没有实现，派生类必须提供自己的实现。纯虚函数通过 = 0 来标记。

• 纯虚函数使得基类变成了一个抽象类，无法实例化，只能作为派生类的基类使用。派生类必须重写所有的纯虚函数，才能实例化对象。

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle\n";
    }
};

int main() {
    // Shape shape;  // 错误，不能实例化抽象类
    Shape* shape = new Circle();
    shape->draw();  // 输出: Drawing Circle
    delete shape;
}

• 在上面的代码中，draw() 是一个纯虚函数，声明为 = 0。Shape 类是一个抽象类，无法直接实例化，必须通过派生类 Circle 提供具体实现后，才能创建对象。

3.析构函数（Destructor）

是一种特殊的成员函数，用于在对象生命周期结束时进行清理操作。它的作用是释放对象占用的资源，比如动态分配的内存、文件句柄、网络连接等，以避免资源泄漏。析构函数的调用发生在对象销毁时，通常是对象超出作用域或者通过 delete 运算符销毁对象时。

1. 析构函数的特点

• 自动调用：析构函数会在对象生命周期结束时自动调用，无需手动调用。

• 不能有返回值：析构函数没有返回值，也不能有参数。

• 只能有一个析构函数：一个类只能有一个析构函数，因为析构函数的签名必须是唯一的（没有参数和返回值），不能有重载。

• 不能被继承：析构函数是类的成员函数，不能被继承或重写，但派生类的析构函数会自动调用基类的析构函数。

• 与构造函数配对：通常，构造函数负责分配资源，析构函数负责释放资源。

2. 析构函数的语法

~ClassName() {
    // 清理资源的代码
}

• ~：表示析构函数的标识符。

• ClassName：表示类的名称。

3. 析构函数的调用时机

• 自动销毁：对象生命周期结束时，系统会自动调用析构函数。这通常发生在以下几种情况下：

  • 局部对象：对象超出作用域时（即函数返回或代码块结束时）。

  • 动态分配的对象：使用 new 创建的对象，调用 delete 时会调用析构函数。

  • 静态对象：当程序结束时，静态对象的析构函数会被调用。

4. 析构函数的作用

析构函数通常用于以下几种任务：

• 释放动态分配的内存：如果构造函数使用 new 关键字为对象分配了内存，析构函数应该释放这些内存。

• 关闭文件或网络连接：如果对象打开了文件、网络连接等，析构函数应该关闭它们，避免资源泄漏。

• 其他清理操作：例如释放锁、关闭数据库连接等。

5. 析构函数的示例

1. 基本示例：释放动态分配的内存

#include <iostream>
using namespace std;

class MyClass {
private:
    int* data;

public:
    // 构造函数：动态分配内存
    MyClass(int value) {
        data = new int;  // 动态分配内存
        *data = value;
        cout << "Constructor: Data = " << *data << endl;
    }

    // 析构函数：释放内存
    ~MyClass() {
        delete data;  // 释放内存
        cout << "Destructor: Memory freed" << endl;
    }
};

int main() {
    MyClass obj(10);  // 创建对象
    // 当 obj 超出作用域时，析构函数会被调用，内存将被释放
    return 0;
}

输出：

Constructor: Data = 10
Destructor: Memory freed

• 在这个例子中，MyClass 的构造函数动态分配了一块内存，并存储了一个整数。析构函数则负责释放这块内存。

• 当对象 obj 超出作用域时，析构函数自动调用，释放 data 指向的内存。

2. 示例：释放文件资源

#include <iostream>
#include <fstream>
using namespace std;

class FileHandler {
private:
    ofstream file;

public:
    // 构造函数：打开文件
    FileHandler(const string& filename) {
        file.open(filename);
        if (file.is_open()) {
            cout << "File opened successfully!" << endl;
        } else {
            cout << "Failed to open file!" << endl;
        }
    }

    // 析构函数：关闭文件
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            cout << "File closed successfully!" << endl;
        }
    }
};

int main() {
    FileHandler handler("example.txt");  // 创建对象并打开文件
    // 当 handler 超出作用域时，析构函数会自动调用，关闭文件
    return 0;
}

输出：

File opened successfully!
File closed successfully!

• 在这个例子中，FileHandler 类的构造函数打开一个文件，而析构函数在对象销毁时关闭文件。

6. 虚析构函数

当类被用作基类，并且需要通过基类指针删除派生类对象时，虚析构函数是必须的。否则，基类的析构函数将不会调用派生类的析构函数，导致资源泄漏。

示例：虚析构函数

#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() {  // 基类虚析构函数
        cout << "Base destructor called" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() override {  // 派生类析构函数
        cout << "Derived destructor called" << endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    delete basePtr;  // 必须使用虚析构函数，正确调用派生类的析构函数
    return 0;
}

输出：

Derived destructor called
Base destructor called

• 在这个例子中，Base 类的析构函数是虚拟的，保证了通过基类指针 basePtr 删除 Derived 类对象时，派生类的析构函数会先被调用，然后才调用基类的析构函数。

7. 总结

• 析构函数用于在对象销毁时释放对象占用的资源，比如动态分配的内存、文件句柄、网络连接等。

• 它在对象生命周期结束时自动调用，不能有参数和返回值，一个类只能有一个析构函数。

• 虚析构函数用于确保通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，防止资源泄漏。

析构函数是面向对象编程中的重要概念，它帮助我们确保资源得到有效释放，避免内存泄漏或其他资源问题。