memory leak when deleting derived class with base-class pointer

Question

I have an issue with a memory leak. I have a base-class pointer. From it, I use new to allocate different derived classes. Then, when I try to delete those classes with the reference (not typecasted), I get a memory leak. I researched the problem and found that I should add a virtual destructor to the base-class, but I tried this and I still have a memory leak; that is, according to my task-manager, the memory usage continues to rise with each allocation and deletion of the derived class using the base-class pointer. I tried making it an abstract destructor and added destructors to the derived classes, but I got an undefined reference error. I also tried typecasting the pointer as a derived-class pointer for the delete, but apparently this crashes the program.

Does anyone have any idea what I should do?

Example code:

class A {
public:
  A();
  ~A() {};
  virtual ~A();      /*or*/
  virtual ~A()=0;    /*or*/
                     /*or nothing?*/
}

class B: private A {
public:
  B();
  ~B() {};           /*this?*/
                     /*or nothing?*/
}

Composition is a good alternative to using private inheritance (http://www.parashift.com/c++-faq-lite/private-inheritance.html#faq-24.3) — James, Mar 03 '11 at 21:38

Axel · Answer 1 · 2011-03-04T00:00:06.023

5

How sure are you that there really is a memory leak? Normally, the task manager won't be much help here, since it cannot tell how much of the memory belonging to your process is actually allocated. Even memory that is freed still belongs to your process, and may be used at later times by the memory management (normally malloc-like system library).

Use a tool such as mallocdebug, valgrind, purify etc. to find out if there's really a memory leak. These tools will replace the malloc implementation by a new one that keeps track of allocated memory and reports memory that is not freed upon process termination.

Note: On most systems, memory that is freed from a process is not returned to the system before the process exits. It is availabe for new allocations from within the same process, though.

edited Mar 04 '11 at 00:00

answered Mar 03 '11 at 21:55

Axel

13,939
5
50
79

+1 for possibly saving AUTO the needless suffering I went through before someone gave me that clue. – ceo Mar 03 '11 at 22:43
maybe, but the task-manager only seems to show the memory increasing slowly - but, it isn't leaking? – Codesmith Mar 03 '11 at 23:57
1

+1 The task manager lies. Mostly. Use a real debugging tool instead of trying to measure the height of an anthill a mile away using misaligned binoculars. – Greg Hewgill Mar 04 '11 at 03:55

score 4 · Accepted Answer · answered Mar 03 '11 at 21:39

4

use virtual ~A();

I'd be surprised if virtual ~A()=0 is allowed.

With this code:

A* base = new B();
delete base;

the destructor for B then A will be called.

If you're really still leaking memory, then you have another leak elsewhere.

answered Mar 03 '11 at 21:39

pure virtual destructor are legal in c++, anyway you have to provide an implementation for it: `struct A { virtual ~A() = 0 };` `A::~A(){}` pure virtual dtor is useful when you want an abstract base class but the dtor is the only virtual method it has – thrantir Jul 23 '14 at 07:59

score 3 · Answer 3 · answered Mar 03 '11 at 21:35

3

If you have a virtual destructor, the destructor(s) of your subclass(es) will all be called. no need to do any esoteric magic with abstract deconstructors or anything.

I would assume the memory leak is somewhere inside your object. Maybe you're calling new() on something in B's (or A's?) constructor, but you don't delete it. Without seeing more code, all I can say is "your destructor setup is fine".

answered Mar 03 '11 at 21:35

EboMike

76,846
14
164
167

Wait - which deconstructor setup? – Codesmith Mar 03 '11 at 21:53

score 1 · Answer 4 · answered Mar 03 '11 at 23:12

You can use:

virtual ~A(){}

or

virtual ~A()=0; 

// as long as there is also:
A::~A(){}  // inline in the header file or non-inline in the cpp file.

This means that:

A* base;
...
delete base;

will call all the destructors of the derived classes in the correct order.

Note that a pure virtual destructor: virtual ~A()=0; can be useful if you need to have an abstract base class when no other member functions are pure virtual.

memory leak when deleting derived class with base-class pointer

4 Answers4

Linked