Looking for Memory Leak Advice

[complete]

Apart from buying BoundsChecker or any of the other tools to track down memory leaks. Does anyone have any advice or tips from your years of programming experience to offer on how to track down the causes of memory leaks?

I find that the big dump that happens at the end of a program does not typically lend any useful clues as to where or what was allocated that was not freed. I find that I have to back track and comment out sections of code until through the process of elimination and trial-and-error, I am able to narrow down where the problem is. And since this is usually at the bottom of the To-Do list, the memory leaks are not plugged.

[teknomage1]

Now obviously I don't know what sort of allocation strategy your program uses or what's appropriate for your problem domain, but you could try making some of your objects reference counted. Boost::SmartPointer is pretty good.

[complete]

Originally Posted by teknomage1

Now obviously I don't know what sort of allocation strategy your program uses or what's appropriate for your problem domain, but you could try making some of your objects reference counted. Boost::SmartPointer is pretty good.

Using some sort of smart pointer is something I will try when all else fails.

The Memory Dump that happens at the end of running the program (It is a Visual C++ MFC program) shows memory locations. I understand I can use this to find where the offending allocation happens. But the memory addresses change each time I run the program -- althought the sizes do not, but this does not give me enough clues.

I wonder if this is just an unavoidable "feature" of MFC.

[DJMaze]

Totally depends who forgets to cleanup something?

When you use

CString *foo = new CString();

but forget to

if (foo) delete foo;

or use

int *integers = new int[20];

but forget to

delete [] integers;

Then it's your fault, else it could be from a library that you use (.NET fun anyone?).

[complete]

Also, I have learned that you need to have a
CoUnitialize()
to go along with every
CoInitailze(0)

I wonder if I need something to go along with my CoCreateInstance calls.

[complete]

Originally Posted by DJMaze

Totally depends who forgets to cleanup something?

When you use

CString *foo = new CString();

but forget to

if (foo) delete foo;

or use

int *integers = new int[20];

but forget to

delete [] integers;

Then it's your fault, else it could be from a library that you use (.NET fun anyone?).

If I have something like this:

  BSTR val;
  SomeFunction(&val);

Will I have to free val somehow?

[landonmkelsey]

as I remember the ways (some of them)

(1)

#include <iostream>
using namespace std;
class Base
{	int*	pBase;
public:
	Base(){pBase=new int[8];cout<<"Base construCTOR"<<endl;}
	virtual ~Base(){delete [] pBase; cout<<"Base destruCTOR"<<endl;}
};
class Derived : public Base
{	int*	pDerived;
	int	ipd;
public:
	Derived()
	{	pDerived=new int[4096];
		cout<<"Derived construCTOR pointer = "<<hex<<pDerived<<endl;
	}
	~Derived(){delete [] pDerived; cout<<"Derived destruCTOR"<<endl;}
};
void
main()
{	for(int i=0; i<4;i++)
	{	Base* pB = new Derived;
		delete pB;
	}
}

To make the program fail, remove the virtual from the base class DTOR.

This exampled demos the concept

If the base class DTOR is virtual, the derived class DTOR will be called and memory allocated by the derived class will be released.


(2) If one stores pointers (created by new) in a container, one should perform a delete on the pointers after extraction (and final use) from the container. Then the rest of the pointers still in the container should be extracted and deleted.

(3) (mentioned above)the concept of a smart pointer is good because when the smart pointer goes out of scope (it is on the stack), its destructor is called and the memory allocation pointer is deleted.

(4) a new operation creates a pointer to memory and the pointer is passed to other methods. The general question is "who's responsibility is it to delete the pointer"

I have a vector program where ownership is decided at insert time. If the "vector" owns the pointers, it deletes the ones stored and the vector dies by going out of scope.

The example deletes the pointer and then allocates another chunk. If the new pointer is beyond the original, there is a memory leak.

(5) hmmm! what else???

If in doubt, add some cout statements and do the bookkeeping!
(6) I'll not mention the programming system but once I would pass on pointers and never get the chance to delete the pointers.

Tech support said "don't worry" SHUHR!