C++中基类的析构函数为什么用virtual虚析构函数

C++中基类采用virtual虚析构函数是为了防止内存泄露的。

具体来说，如果派生类申请了内存空间，并在其析构函数中对该内存空间进行释放，如果基类采用的非虚析构函数，则删除基类指针指向的派生类对象时，就不会触发动态绑定，因此，只会调用基类的虚构函数，而不会调用该派生类的析构函数。因此，在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。为了防止该情况的发生，C++中基类的析构函数应该采用virtual虚析构函数。
关于动态绑定，简单来说，虚函数是动态绑定的基础，动态绑定是实现运行多态的基础，需要触发动态绑定，需要满足以下两个条件：

只有虚函数才能进行动态绑定，非虚函数不能进行动态绑定。

必须通过基类的引用或指针进行函数的调用。

通过基类指针或基类引用做形参，当实参传入不同的派生类(或基类)的指针或引用，在函数内部触发动态绑定，从而来运行时实现多态的。

示例代码讲解

using namespace std;

class Base {
public:
    ~Base() {
        cout << "~Base()" << endl;
    }
};

class Derived1 : public Base {
public:
    Derived1():name_(new string("NULL")) {}
    Derived1(const string& n):name_(new string(n)) {
    }
    ~Derived1() {
        delete name_;
        cout << "~Derived1(): name_ has been deleted." << endl;
    }

private:
    string* name_;
};

class Derived2 : public Base {
public:
    Derived2():name_(new string("NULL")) {}
    Derived2(const string& n):name_(new string(n)) {}
    ~Derived2() {
        delete name_;
        cout << "~Derived2(): name_ has been deleted." << endl;
    }

private:
    string* name_;
};


int main() {
    Derived1* d1 = new Derived1();
    Derived2 d2 = Derived2("Bob");
    delete d1;
    return 0;
}

代码运行结果如图：
在这里插入图片描述
d1为Derived1类的指针，它指向一个在堆上创建的Derived1的对象；d2为一个在栈上创建的对象。其中d1所指的对象需要我们显式的用delete调用其析构函数；d2对象在其生命周期结束时，系统会自动调用其析构函数。
由于，Base基类的析构函数并不是虚析构函数，现在结果显示，派生类的析构函数被调用了，正常的释放了其申请的内存资源。这两者并不矛盾，因为无论是d1还是d2，两者都属于静态绑定，而且其静态类型恰好都是派生类，因此，在析构的时候，即使基类的析构函数为非虚析构函数，也会调用相应派生类的析构函数。

当发生动态绑定时，也就是当用基类指针指向派生类，这时候采用delete显式删除指针所指对象时，如果Base基类的析构函数没有virtual，会发生什么情况？修改main函数如下：

int main() {
  Base* base[2] = {
    new Derived1(),
    new Derived2("Bob")      
  };
  for (int i = 0; i != 2; ++i) {
    delete base[i];    
  }
  return 0;
}

运行结果如下：
在这里插入图片描述
尽管派生类中定义了析构函数来释放其申请的资源，但是并没有得到调用。原因是基类指针指向了派生类对象，而基类中的析构函数却是非virtual的，之前讲过，虚函数是动态绑定的基础。现在析构函数不是virtual的，因此不会发生动态绑定，而是静态绑定，指针的静态类型为基类指针，因此在delete时候只会调用基类的析构函数，而不会调用派生类的析构函数。这样，在派生类中申请的资源就不会得到释放，就会造成内存泄漏，这是相当危险的：如果系统中有大量的派生类对象被这样创建和销毁，就会有内存不断的泄漏，久而久之，系统就会因为缺少内存而崩溃。

在基类的析构函数为非虚析构函数的时候，并不一定会造成内存泄漏；当派生类对象的析构函数中有内存需要收回，并且在编程过程中采用了基类指针指向派生类对象，如为了实现多态，并且通过基类指针将该对象销毁，这时，就会因为基类的析构函数为非虚析构函数而不触发动态绑定，从而没有调用派生类的析构函数而导致内存泄漏。因此，为了防止这种情况下内存泄漏的发生，最好将基类的析构函数写成virtual虚析构函数。

将基类的析构函数改为虚析构函数：

class Base {
 public:
virtual ~Base() {
  cout << "~Base()" << endl;
}
};

运行结果如下：
在这里插入图片描述
这样就会实现动态绑定，派生类的析构函数就会得到调用，从而避免了内存泄漏。

综上，继承时，要养成的一个好习惯就是，基类析构函数中，加上virtual。

来源：CSDN

作者：肥宅快乐谁

链接：https://blog.csdn.net/weixin_43078345/article/details/88083039

标签

析构函数

指针

动态绑定

内存泄漏

delete

派生类

virtual