抽象类里的析构函数例子

当一个类中含有虚函数时，通常我们需要为其定义一个虚析构函数，以确保在删除指向派生类对象的基类指针时，能够正确地调用派生类的析构函数，避免内存泄漏和未定义的行为。

而对于抽象类而言，由于其不能被实例化，因此其析构函数也需要被声明为纯虚函数，以确保其子类必须定义自己的析构函数。

以下是一个抽象类中含有纯虚析构函数的例子：

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

Base::~Base() {} // 必须提供定义

class Derived : public Base {
public:
    ~Derived() override {
        // 派生类析构函数的具体实现
    }
};

在上述例子中，`Base` 类包含一个纯虚析构函数 `~Base()`，而 `Derived` 类继承自 `Base`，并覆盖了 `~Base()`。

需要注意的是，由于 `~Base()` 是一个纯虚函数，因此其必须提供定义。在此例中，我们通过在类外部定义 `~Base()` 来实现这一点。

相关问题

c++抽象类虚析构函数

### C++ 中抽象类的虚析构函数

#### 定义与特性
在C++中，当一个类包含至少一个纯虚函数时，则该类成为抽象类。抽象类不能直接实例化对象，仅能用于派生其他具体类。为了确保多态行为下的资源正确释放，建议将抽象类的析构函数声明为虚函数。

对于抽象类而言，即使本身不提供具体的实现细节，也应当考虑为其定义虚析构函数：

class AbstractClass {
public:
    virtual ~AbstractClass() {} // 虚析构函数
};

这样做是为了保证删除指向派生类对象的基类指针时能够调用正确的析构序列[^1]。

#### 使用场景及意义
假设存在如下继承结构:

#include <iostream>
using namespace std;

// 基类（抽象类）
class Shape {
public:
    virtual void draw() = 0;      // 纯虚函数
    virtual ~Shape(){}            // 虚析构函数
};

// 派生类之一
class Circle : public Shape {
public:
    void draw() override {        // 实现draw()
        cout << "Drawing a circle." << endl;
    }
    
    ~Circle(){
        cout << "~Circle destructor called" << endl;
    }
};

int main(){
    Shape* shapePtr = new Circle();
    delete shapePtr;              // 此处会先调用Circle::destructor再调用Shape::destructor
}

上述代码展示了如何利用虚析构函数来安全地销毁动态分配的对象。如果`Shape`类没有设置成虚析构函数，在执行`delete shapePtr`操作时只会触发`Shape::~Shape()`而不会触及实际创建出来的`Circle`部分的数据成员清理逻辑[^3]。

因此，在涉及多态性和运行期绑定的情况下，尤其是通过基类指针管理派生类对象生命周期的应用场合里，应该总是把基类的析构函数设为虚函数以保障程序的安全性与稳定性[^4]。

c++纯虚函数的析构函数实现例子

当一个类中有至少一个纯虚函数，我们称之为抽象类。抽象类不能被实例化，只能被继承。在抽象类中定义的纯虚函数不需要实现。但是，如果抽象类中有成员变量需要在析构函数中被释放，那么该类的析构函数必须被定义。

下面是一个例子，展示如何在抽象类中定义纯虚函数和析构函数的实现：

#include <iostream>

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

    virtual void draw() = 0; // 纯虚函数

    void setX(int x) {
        this->x = x;
    }

    void setY(int y) {
        this->y = y;
    }

    int getX() const {
        return x;
    }

    int getY() const {
        return y;
    }

protected:
    int x;
    int y;
};

Shape::~Shape() {
    std::cout << "Shape destructor called." << std::endl;
}

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle at (" << getX() << ", " << getY() << ")" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle at (" << getX() << ", " << getY() << ")" << std::endl;
    }
};

int main() {
    Shape* shapes[2] = {new Circle(), new Rectangle()};
    shapes[0]->setX(10);
    shapes[0]->setY(20);
    shapes[1]->setX(30);
    shapes[1]->setY(40);

    for(int i = 0; i < 2; i++) {
        shapes[i]->draw();
        delete shapes[i];
    }

    return 0;
}

在这个例子中，我们定义了一个抽象类 `Shape`，其中包含一个纯虚函数 `draw()` 和一个成员变量。由于 `Shape` 是一个抽象类，因此其析构函数必须是一个纯虚析构函数。在 `Shape` 的析构函数中，我们打印一条消息，以便在对象被销毁时进行调试。

我们还定义了两个继承自 `Shape` 的类：`Circle` 和 `Rectangle`。这两个类都实现了 `draw()` 函数。

在 `main()` 函数中，我们创建了一个 `Shape` 指针类型的数组，并使用 `new` 运算符在堆上创建了两个对象：`Circle` 和 `Rectangle`。我们设置了每个对象的 `x` 和 `y` 坐标，并调用了它们的 `draw()` 函数。最后，我们使用 `delete` 运算符释放了数组中的每个对象。

该程序的输出应该如下所示：

Drawing a circle at (10, 20)
Shape destructor called.
Drawing a rectangle at (30, 40)
Shape destructor called.