Does delete on a pointer to a subclass call the base class destructor?

by

The destructor of A will run when its lifetime is over. If you want its memory to be freed and the destructor run, you have to delete it if it was allocated on the heap. If it was allocated on the stack this happens automatically (i.e. when it goes out of scope; see RAII). If it is a member of a class (not a pointer, but a full member), then this will happen when the containing object is destroyed.

class A
{
    char *someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { delete[] someHeapMemory; }
};

class B
{
    A* APtr;
public:
    B() : APtr(new A()) {}
    ~B() { delete APtr; }
};

class C
{
    A Amember;
public:
    C() : Amember() {}
    ~C() {} // A is freed / destructed automatically.
};

int main()
{
    B* BPtr = new B();
    delete BPtr; // Calls ~B() which calls ~A() 
    C *CPtr = new C();
    delete CPtr;
    B b;
    C c;
} // b and c are freed/destructed automatically

In the above example, every delete and delete[] is needed. And no delete is needed (or indeed able to be used) where I did not use it.

auto_ptr, unique_ptr and shared_ptr etc… are great for making this lifetime management much easier:

class A
{
    shared_array<char> someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { } // someHeapMemory is delete[]d automatically
};

class B
{
    shared_ptr<A> APtr;
public:
    B() : APtr(new A()) {}
    ~B() {  } // APtr is deleted automatically
};

int main()
{
    shared_ptr<B> BPtr = new B();
} // BPtr is deleted automatically

More Related Contents:

  1. Why, really, deleting an incomplete type is undefined behaviour?
  2. C++ – destructors [closed]
  3. Is delete[] equal to delete?
  4. delete vs delete[] operators in C++
  5. Is “delete this” allowed in C++?
  6. Is it safe to delete a NULL pointer?
  7. Dynamically allocating an array of objects
  8. delete vs delete[] [duplicate]
  9. Why doesn’t delete set the pointer to NULL?
  10. Is it possible to delete a non-new object?
  11. What happens when you deallocate a pointer twice or more in C++?
  12. The difference between delete and delete[] in C++ [duplicate]
  13. Is the whole object freed with a non-virtual destructor and a Base class pointer?
  14. How do malloc() and free() work?
  15. How could pairing new[] with delete possibly lead to memory leak only?
  16. Why do we need a pure virtual destructor in C++?
  17. Compelling examples of custom C++ allocators?
  18. How to get available memory C++/g++?
  19. How does a C++ reference look, memory-wise?
  20. Any reason to overload global new and delete?
  21. Are memory leaks “undefined behavior” class problem in C++?
  22. Why don’t STL containers have virtual destructors?
  23. Destructor being called twice when being explicitly invoked
  24. When to use new and delete
  25. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?
  26. How do I call the original “operator new” if I have overloaded it?
  27. If a 32-bit integer overflows, can we use a 40-bit structure instead of a 64-bit long one?
  28. Calling delete on NULL pointers – C++03 vs C++11
  29. What happen to pointers when vectors need more memory and realocate memory?
  30. C++ delete does not free all memory (Windows)

Leave a Comment