将析构函数改成虚析构函数

当一个类中有虚函数时，如果该类的对象被删除，只会调用该类的析构函数，不会调用任何派生类的析构函数。这就会导致派生类中的资源没有被释放，从而出现内存泄漏。

为了解决这个问题，需要将析构函数改成虚析构函数。虚析构函数是指在基类中将析构函数声明为虚函数，这样当一个对象的指针被删除时，会调用该对象所属类的析构函数，从而保证所有资源被正确释放。

示例代码如下：

class Base {
public:
    virtual ~Base() {
        // 基类析构函数
    }
};

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

在上面的代码中，`Base` 类的析构函数被声明为虚析构函数，而 `Derived` 类的析构函数使用了 `override` 关键字覆盖了基类的虚析构函数。这样，当一个 `Derived` 类的对象被删除时，会先调用 `Derived` 类的析构函数，再调用 `Base` 类的析构函数，从而保证资源被正确释放。

相关问题

#include<iostream> using namespace std; class Date{ public: Date(int y,int m,int d):year(y),month(m),day(y) { cout<<"构造函数"<<endl;} Date(Date &d) { year=d.year;month=d.month;day=d.day; cout<<"copying"<<endl; } Date(){ } ~Date() { cout<<"析构函数"<<endl; } void display() { cout<<year<<month<<day<<endl; } private: int year,month,day; }; Date fun(Date d) { Date t=d; cout<<"in fun"<<endl; return t; } int main() { Date d1(2016,10,1); Date d2(2020,3,9); Date d3=d2; fun(d1); Date d4=fun(d2); return 0; }运行结果及其分析

运行结果：

构造函数
copying
构造函数
构造函数
in fun
copying
析构函数
析构函数
析构函数
析构函数
析构函数

分析：

1. 首先在 main 函数中创建了对象 d1 和 d2，并且用 d2 初始化了 d3。

2. 在调用 fun 函数前，会调用 Date 类的拷贝构造函数，将 d1 作为参数传入 fun 函数。在 fun 函数内部，又会调用一次拷贝构造函数，将参数 d 传入，创建了一个临时对象 t。

3. 在 fun 函数结束后，会将 t 作为返回值传回到 main 函数中，此时又会调用一次拷贝构造函数，将 t 复制给 d4。

4. 在 main 函数结束后，d1、d2、d3、d4 四个对象都被销毁，因此会调用四次析构函数。

5. 注意到构造函数中初始化 day 成员变量时错误地使用了 year 参数，应该改成 d 参数。

请将上面实现改成小根堆

好的，以下是将上面的大根堆实现改成小根堆的代码：

template <typename T>
class PriorityQueue {
public:
    // 构造函数
    PriorityQueue() {
        // 初始化堆大小
        capacity = 10;
        // 初始化堆数组
        heap = new T[capacity];
        // 初始化堆大小为0
        size = 0;
    }

    // 析构函数
    ~PriorityQueue() {
        delete[] heap;
    }

    // 入队
    void push(const T& value) {
        // 如果堆已满，则进行扩容
        if (size == capacity) {
            resize();
        }
        // 将元素插入堆尾
        heap[size++] = value;
        // 上浮操作
        siftUp(size - 1);
    }

    // 出队
    void pop() {
        // 如果堆为空，则直接返回
        if (empty()) {
            return;
        }
        // 将堆尾元素移到堆顶
        heap[0] = heap[--size];
        // 下沉操作
        siftDown(0);
    }

    // 获取队列大小
    int size() const {
        return size;
    }

    // 判断队列是否为空
    bool empty() const {
        return size == 0;
    }

    // 获取队头元素
    T top() const {
        return heap[0];
    }

private:
    // 堆数组
    T* heap;
    // 堆的大小
    int size;
    // 堆的容量
    int capacity;

    // 上浮操作
    void siftUp(int index) {
        // 父节点的索引
        int parent = (index - 1) / 2;
        // 当前节点比父节点小，则交换它们
        while (index > 0 && heap[index] < heap[parent]) {
            std::swap(heap[index], heap[parent]);
            index = parent;
            parent = (index - 1) / 2;
        }
    }

    // 下沉操作
    void siftDown(int index) {
        while (true) {
            // 左子节点的索引
            int leftChild = index * 2 + 1;
            // 右子节点的索引
            int rightChild = index * 2 + 2;
            // 用于比较的最小值索引
            int minIndex = index;
            // 如果左子节点比当前节点小，则更新最小值索引
            if (leftChild < size && heap[leftChild] < heap[minIndex]) {
                minIndex = leftChild;
            }
            // 如果右子节点比当前节点小，则更新最小值索引
            if (rightChild < size && heap[rightChild] < heap[minIndex]) {
                minIndex = rightChild;
            }
            // 如果最小值索引不是当前节点，则交换它们，并继续下沉
            if (minIndex != index) {
                std::swap(heap[index], heap[minIndex]);
                index = minIndex;
            }
            else {
                // 否则，已经满足堆的性质，退出循环
                break;
            }
        }
    }

    // 扩容操作
    void resize() {
        // 新容量为原来的两倍
        capacity *= 2;
        // 新建一个更大的数组
        T* newHeap = new T[capacity];
        // 将原有元素复制到新数组中
        for (int i = 0; i < size; i++) {
            newHeap[i] = heap[i];
        }
        // 删除原有数组
        delete[] heap;
        // 更新指针
        heap = newHeap;
    }
};

在这个实现中，我们将比较运算符由“>”改为“<”，同时将最大值的概念改为最小值的概念。