转载：C++中基类的析构函数，为什么要用virtual虚析构函数！

小鱼儿 2023-05-21 07:17 7阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhbXVzaXF1ZQ_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhbXVzaXF1ZQ_size_16_color_FFFFFF_t_70 1][]

可参考 [https://blog.csdn.net/iicy266/article/details/11906509][https_blog.csdn.net_iicy266_article_details_11906509]

直接的讲，**C++中基类采用virtual虚析构函数是为了防止内存泄漏。**

具体地说，如果派生类中申请了内存空间（new malloc calloc），并在其析构函数中对这些内存空间进行释放（就需要**手写delete free**）。假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，**派生类中申请的空间就得不到释放从而产生内存泄漏**。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

# 示例代码讲解 #

现有Base基类，其析构函数为非虚析构函数。Derived1和Derived2为Base的派生类，这两个派生类中均有以string\* 指向存储其name的地址空间，**name对象是通过new创建在堆上的对象，因此在析构时，需要显式调用delete删除指针归还内存，否则就会造成内存泄漏。**

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对象在其生命周期结束时，系统会自动调用其析构函数。

无论是d1还是d2，两者都属于**静态绑定**，而且其静态类型恰好都是派生类，因此，在析构的时候，即使基类的析构函数为非虚析构函数，也会调用相应派生类的析构函数。**结果显示，派生类的析构函数被调用了，正常的释放了其申请的内存资源。**

**测试场景二：**

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

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时候仍然只会调用基类的析构函数，而不会调用派生类的析构函数**。

**结果：**仍然导致，派生类中申请的资源就不会得到释放，就会造成内存泄漏，这是相当危险的：如果系统中有大量的派生类对象被这样创建和销毁，就会有内存不断的泄漏，久而久之，系统就会因为缺少内存而崩溃。

**总结：**也就是说，在基类的析构函数为非虚析构函数的时候，并不一定会造成内存泄漏（你得 动态绑定即基类指针指向子类对象、delete/free它！）；当派生类对象的析构函数中**有堆内存需要收回delete/free函数**，并且在编程过程中**采用了基类指针指向派生类对象**，如为了实现多态，并且通过基类指针将该对象销毁，这时，就会因为**基类的析构函数为非虚析构函数而不触发动态绑定，从而没有调用派生类的析构函数而导致内存泄漏。**

因此，为了防止这种情况下内存泄漏的发生，最好将基类的析构函数写成virtual虚析构函数。下面把Base基类的析构函数改为虚析构函数：

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

这样就会实现动态绑定，派生类的析构函数就会得到调用，从而避免了内存泄漏。

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhbXVzaXF1ZQ_size_16_color_FFFFFF_t_70]: /images/20230521/43ce7002ba4d47bea6249346ea2dd39a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhbXVzaXF1ZQ_size_16_color_FFFFFF_t_70 1]: /images/20230521/3d00af2d8e12432cb6ffe25a9d25ff9c.png
[https_blog.csdn.net_iicy266_article_details_11906509]: https://blog.csdn.net/iicy266/article/details/11906509