C++ 虚析构函数

2025年8月29日 | 阅读 7 分钟

在 C++ 中，虚析构函数用于在使用基类指针对象删除派生类实例时，释放派生类对象或实例分配的内存空间。基类或父类析构函数使用 virtual 关键字，确保基类和派生类析构函数都将在运行时被调用，但它会首先调用派生类，然后调用基类来释放两个析构函数占用的空间。

语法

它具有以下语法：

class Base {
public:
    virtual ~Base(); // Virtual destructor
};

简单的虚析构函数示例

让我们看一个 C++ 中虚析构函数的示例。

示例

#include <iostream>
using namespace std;  //using standard namespace
class Base {
public:   //Access Modifier
    virtual ~Base() {
        cout << "Base Destructor\n";
    }
};
class Derived : public Base {   //Derived Class
public:
    ~Derived() {
        cout << "Derived Destructor\n";
    }
};
int main() {   //Main Function
    Base* ptr = new Derived();  // Base pointer to Derived object
    delete ptr;     // Delete via base pointer
    return 0;
}

编译并运行

输出

Derived Destructor
Base Destructor

说明

在此示例中，ptr 是一个基类指针，用于指向 Derived 对象。Base 具有一个虚析构函数。当在 main() 函数中执行 delete ptr 时，将首先调用 Derived 类的析构函数，然后调用 Base 类的析构函数。它确保对象中派生部分和基部分的正确清理。

为什么我们在 C++ 中使用虚析构函数？

当类中的对象超出作用域或 main() 函数的执行即将结束时，程序会自动调用析构函数，以释放类析构函数占用的空间。当删除指向派生类的基类指针对象时，由于编译器的早期绑定，只调用父类析构函数。这样，它会跳过调用派生类的析构函数，从而导致程序中出现内存泄漏问题。

如果我们在基类中析构函数波浪号 (~) 符号前使用 virtual 关键字，它保证首先调用派生类的析构函数。之后，调用基类的析构函数，以释放继承类中两个析构函数占用的空间。

虚析构函数内部工作原理

在 C++ 中，编译器在创建虚函数类及其事件析构函数时生成虚表实体。类的所有对象都在其结构内部维护秘密虚表指针。

C++ 通过虚表访问执行运行时类型检查，以确定当析构函数具有 virtual 指定时需要执行哪些析构函数。

虚析构函数的使用

C++ 中虚析构函数有几种用法。其中一些如下：

1) 通过基指针进行多态删除

如果虚析构函数不可用，基类指针尝试删除派生类对象将只执行其基类析构函数。派生类的析构函数无法执行，从而导致资源泄漏。

C++ 通过基指针进行多态删除

让我们看一个示例来说明 C++ 中通过基指针进行多态删除。

示例

#include <iostream> 
using namespace std;  //using standard namespace
class Base {
public:
    ~Base() {
        cout << "Base Destructor\n";
    }
};
class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived Destructor\n";
    }
};
int main() {  //Main Function
    Base* ptr = new Derived();
    delete ptr; // Undefined behavior
    return 0;
}

编译并运行

输出

Base Destructor

说明

在此示例中，基类未能包含虚析构函数声明。delete ptr 语句触发 Base 析构函数并跳过任何 Derived 析构函数的执行。之后，派生对象将遭受资源泄漏，因为这些对象无法释放动态内存或文件句柄。

2) 接口式基类

在 C++ 中，基类上的虚析构函数声明允许我们使用虚表在运行时正确执行析构函数序列。

示例

让我们看一个示例来说明 C++ 中的接口式基类。

示例

#include <iostream>
using namespace std;  //using standard namespace
class Base {
public:  //Access Modifier
    virtual ~Base() {
        cout << "Base Destructor\n";
    }
};
class Derived : public Base {   //Derived Class
public:
    ~Derived() {
        cout << "Derived Destructor\n";
    }
};
int main() {    //Main Function
    Base* ptr = new Derived();
    delete ptr; // Safe deletion
    return 0;
}

编译并运行

输出

Derived Destructor  
Base Destructor

说明

在此示例中，两个析构函数都以正确的顺序调用。之后，保证了完整的对象销毁。

3) 管理派生类中的动态资源

在 C++ 中，派生类分配内存或文件句柄等资源。如果基类中的析构函数不是虚函数，则如果以多态方式删除，它将永远不会被释放。

C++ 示例管理派生类中的动态资源

让我们看一个示例来说明如何在 C++ 中管理派生类中的动态资源。

示例

#include <iostream>
using namespace std;   //using standard namespace
class Base {
public:
    virtual ~Base() {
        cout << "Base cleaned up\n";
    }
};
class Derived : public Base {
private:
    int* data;
public:
    Derived() {
        data = new int[5];
        cout << "Derived allocated memory\n";
    }
    ~Derived() {
        delete[] data;
        cout << "Derived released memory\n";
    }
};
int main() {   //Main Function
    Base* b = new Derived();
    delete b; // Proper cleanup
    return 0;
}

编译并运行

输出

Derived allocated memory  
Derived released memory  
Base cleaned up

说明

在此示例中，当在派生类中管理资源时，我们防止了内存泄漏。

C++ 示例，在不使用虚析构函数的情况下显示类析构函数

让我们看一个程序，在不使用 C++ 中的虚析构函数的情况下，显示类析构函数的不确定行为。

示例

#include<iostream>  
using namespace std;   //using standard namespace
class Base  
{                              
    public: //Access Modifier
    Base() // Constructor function.   
{  
    cout<< "\n Constructor Base class";  
}  
 ~Base() // Destructor function   
{  
    cout<< "\n Destructor Base class";  
}  
};  
class Derived: public Base  
{  
    public: 
    Derived() // Constructor function   
{  
    cout << "\n Constructor Derived class" ;  
}  
 ~Derived() // Destructor function   
{  
    cout << "\n Destructor Derived class" ; /* Destructor function is not called to release its space. */  
}         
};  
int main()    //Main Function
{  
    Base *bptr = new Derived; // Create a base class pointer object   
       delete bptr;  //delete pointer
}

编译并运行

输出

Constructor Base class
 Constructor Derived class
 Destructor Base class

说明

在此示例中，我们使用 Base* 指针创建 Derived 对象。我们还使用了基类。之后，它删除基类析构函数和派生类析构函数占用的指针对象。基类指针只删除基类的析构函数，而不调用程序中派生类的析构函数。因此，它会导致程序中的内存泄漏。

C++ 示例，使用虚析构函数显示类析构函数

让我们看一个程序，在 C++ 中使用虚析构函数显示类析构函数的行为。

示例

#include<iostream>  
using namespace std;   //using standard namespace
class Base  
{  
    public:  
    Base() // Constructor member function.    
{  
    cout << "\n Constructor Base class";  // It prints first.  
}  
 virtual ~Base() // Define the virtual destructor function  
{  
    cout << "\n Destructor Base class";
}  
};  
// Inheritance concept  
class Derived: public Base   
{  
    public:  
    Derived() // Constructor function.  
{  
    cout << "\n Constructor Derived class"; 
}  
 ~Derived() // Destructor function   
{  
    cout << "\n Destructor Derived class"; 
}         
};  
int main() //Main Function
{  
    Base *bptr = new Derived; // A pointer object references the Base class.  
    delete bptr; // Delete the pointer object.  
}  

编译并运行

输出

Constructor Base class
 Constructor Derived class
 Destructor Derived class
 Destructor Base class

说明

在上面的程序中，我们在基类中使用了虚析构函数，它在调用基类析构函数之前调用派生类析构函数，并释放空间或解决程序中的内存泄漏问题。

结论

总之，C++ 中虚析构函数的实现允许在多态类继承设计中正确清理对象。通过虚析构函数，系统可以在使用基指针删除时执行基类和派生类析构函数。当缺少虚析构函数时，只有基析构函数会收到调用，这会将内存置于风险之中。