纯虚析构函数的额外使用原因、使用方法及适用场景咨询

Great question! Let's unpack this—pure virtual destructors serve more purposes than just cleaning up dynamically allocated memory in derived classes, and your code example perfectly illustrates how they work in practice.

Other Reasons to Use Pure Virtual Destructors #

• Force the base class to be abstract: A class with any pure virtual function can't be instantiated directly. If you want a base class that's only meant to be inherited from (never created on its own), adding a pure virtual destructor is a clean way to enforce this—even if there are no other pure virtual methods in the class.
• Guarantee proper polymorphic destruction: Even if your derived class doesn't have dynamic memory, it might hold other resources (like file handles, network connections, or mutex locks) that need explicit cleanup. A pure virtual destructor ensures that when you delete a derived class object through a base class pointer, the derived class's destructor is called first, followed by the base's—preventing resource leaks that would happen if the base destructor wasn't virtual.

How to Use Pure Virtual Destructors (With Your Code Example) #

Let's walk through your code snippet to break down the key parts:

class Base { 
public: 
    virtual ~Base() = 0; // Declare pure virtual destructor
}; 
Base::~Base() {}; // Provide an empty definition for the pure virtual destructor
class Derived: public Base { 
public: 
    ~Derived() override { 
        std::cout << "Deleting Dynamically allocated Memory" << std::endl; 
    } 
};

Critical Usage Rules: #

1. Declare the pure virtual destructor: The line virtual ~Base() = 0; marks the destructor as pure virtual, making Base an abstract class (you can't do Base b;—this will throw a compile error).
2. Always provide a definition for the pure virtual destructor: Unlike regular pure virtual functions, a pure virtual destructor must have a body. When a derived class's destructor runs, it automatically calls the base class's destructor. If you skip the definition, you'll get a linker error. In your example, Base::~Base() {}; is the empty (but necessary) implementation.
3. Override in derived classes: Using override (C++11+) for the derived class destructor is a best practice—it makes your code more readable and catches typos (like misspelling the destructor name) at compile time. The derived destructor handles cleanup for its own resources (like your dynamic memory message), then the base destructor runs automatically.

Example of Proper Usage #

Here's how you'd use these classes in practice:

int main() {
    Base* myDerived = new Derived();
    delete myDerived; // Calls Derived::~Derived() first, then Base::~Base()
    // Base invalidBase; // Compile error: Base is abstract, can't instantiate
    return 0;
}

When you run this, you'll see the message "Deleting Dynamically allocated Memory" printed—proof that the derived class's destructor is being called correctly, even though we're deleting through a base pointer.

Ideal Scenarios for Pure Virtual Destructors #

• Polymorphic base classes: When you design a base class to act as an interface for multiple derived classes (e.g., a Shape base class for Circle, Square, etc.), using a pure virtual destructor ensures proper cleanup and prevents direct instantiation of the base.
• Interface-only classes: If your base class exists solely to define a contract (no member variables or concrete methods), a pure virtual destructor is essential. Even if all other methods are pure virtual, the destructor needs a definition to support the derived class's destructor chain.
• Preventing accidental instantiation: When you want to make sure developers can't create objects of the base class (only its derivatives), a pure virtual destructor is a straightforward way to enforce this without adding unnecessary pure virtual methods.

内容的提问来源于stack exchange，提问作者Native Nova