Cause of a memory leak in C++ when using the Boehm GC

Question

This code is causing a memory leak for me, and I'm not sure why.

[EDIT] Included code from here into question:

#include "src/base.cpp"

typedef std::map<std::string, AlObj*, std::less<std::string>, 
  gc_allocator<std::pair<const std::string, AlObj*> > > KWARG_TYPE;

AlInt::AlInt(int val)   {
    this->value = val;
    this->setup();
}

// attrs is of type KWARG_TYPE
void AlInt::setup() {
    this->attrs["__add__"] = new AddInts();
    this->attrs["__sub__"] = new SubtractInts();
    this->attrs["__mul__"] = new MultiplyInts();
    this->attrs["__div__"] = new DivideInts();
    this->attrs["__pow__"] = new PowerInts();
    this->attrs["__str__"] = new PrintInt();
}

int main() {
    while (true) {
        AlObj* a = new AlInt(3);
    }
}

AlInt inherits from AlObj, which in turn inherits from gc. When I comment out the contents of setup() then I don't have a memory leak, this leads me to believe the issue is with the map not cleaning up, however I'm using the gc allocator, so I'm not sure where to look next. Thoughts?

Answer 1

The 'gc allocator' is allocating and looking after objects of this type:

std::pair<const std::string, AlObj*>

Just because this object has a pointer in it does not mean it the allocator will call delete on it.

If you want the object created in setUp() to be GC then you need to allocate them via the GC. Or learn to use boost:ptr_map or shared_ptr.

A map destroys (not deletes) the object it owns. In this case it owns the pointer not what the pointer points at. So when the map is destroyed it deallocates everything associated with the map and the object it owns (for pointers this means it does nothing).

If you have a map (or other container) that contains pointers. You must manually delete the pointers otherwise there will be a memory leak. Alternatively you can use boost::ptr_map or a map that contains a share_ptr

Answer 2

Actually I'm not sure I follow, AlObj has a member attrs which is a map, not a pointer to a map, so how would I deallocate it?

Answer 3

Essentially what I'm saying is, the AlObj seems to be destructed, but not it's members(since it doesn't leak unless I put stuff in attrs).

Answer 4

The allocator is deleting your pairs. But deleting a pair doesn't delete members of the pair that happen to be pointers.

Answer 5

Ok so it sounds like I need to delete the pointers myself, but what if the pointer points to something that's also being pointed at elsewhere, I don't want to actually free the memory in that case, which I think was the point of the GC.