Memory leak strcore.cpp(141)

>>I use Visual Studio .Net MFC.
Actually MFC is nothing to do with .NET

In the page do you code like
CString* s = new CString();

If you do then you are missing the
delete s;

Do you allocate some object in the the sheet and in the pages?

Also note code like the following is also going to give a memory leak
struct st
{
CString s;
}

in the property page
struct* st = new struct;

//delete st; //missing delete to free the memory of the CString as well as the struct

Put the following at the beginning of each .cpp file:

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

It should help you to find where the object are allocated.

http://msdn.microsoft.com/en-us/library/tz7sxz99(VS.80).aspx

ASKER

Oops! ... sorry. It is Visual Studio 2008.

I don't use any CString* s = new CString();
I use also CObArray but I'm surely that I have delete it in destructor.

See also
"Memory Leak Detection in MFC"
at
http://msdn.microsoft.com/en-us/library/c99kz476(VS.80).aspx

>>>> I use also CObArray but I'm surely that I have delete it in destructor.

You need also to delete every object allocated dinamically with new and added to the CObArray

Anything you create with a new operator needs a corresponding delete operation to free the memory else you have a memory leak. The destructor of a collection (eg. array) does NOT do that for you.

ASKER

What I have done below is not enough to delete CObArray?

It would be nice, if any one show me the example code about object allocated dynamically and delete the object.

Thank you very much in advance. :)

========== Initialize Page 1==========
 
this->currentPosition = 0;
c1 = new component("AAA", 1, 2, 3);
this->myList.Add(c1);
c2 = new component("BBB", 4, 5, 6);
this->myList.Add(c2);
 
=============================
 
========== destructor ==========
 
//*** Delete CObArray.
for(int i=0; i<myList.GetUpperBound(); i++) 
{
     delete myList.GetAt(i);
}
myList.RemoveAll();
 
=============================

Open in new window

you should use <= instead of <

for(int i=0; i<=myList.GetUpperBound(); i++)

That should be OK.

opps sorry, not OK - use GetCount instead of GetUpperBound

pgnatyuk

You can try this code for the array clear:
component* p = NULL;
for(int i=0; i<myList.GetUpperBound(); i++)
{
p = myList.GetAt(i);
delete p;
p = NULL;
}
myList.RemoveAll();

ASKER CERTIFIED SOLUTION

membership

This solution is only available to members.

To access this solution, you must be a member of Experts Exchange.

Start Free Trial

pgnatyuk

Nice. :)
So just a very small addition:
int nCount = myList.GetSize();
component* p = NULL;
while (nCount > 0)
{
nCount--;
p = myList.GetAt(nCount);
if (p != NULL)
{
delete p;
p = NULL;
}
}
myList.RemoveAll();

longer. but this approach, from my POV, does not give a chance for a leak.

>>>>> if (p != NULL)
delete NULL pointer is allowed in C++ so you don't need this check.

>>>>> p = myList.GetAt(nCount);
you cannot assign a CObject* to a component* (you need a cast)

>>>>> p = NULL;
assign NULL to p is useless since it is no more used in the code.

So, chang2008's code is quite OK, but she must use <= instead of <

SOLUTION

membership

This solution is only available to members.

To access this solution, you must be a member of Experts Exchange.

Start Free Trial

pgnatyuk

Agreed. :)

itsmeandnobodyelse

If I see right it is three strings which were not freed.

Does the object which you delete at

delete myList.GetAt(i);

has 3 string members?

If not there are still more leaks.

Check all occurrences of CObArray::GetUpperBound() and replace them by CObArray::GetCount or CObArray::GetSize as suggested by AndyAinscow. If your loops always start by 0 and have a less < for termination you'll make your life happier ...

Another possibility where leaks may occur are static CString member variables or CString member variables of static class instances. The leak output occurs before destructors of static class members have run.

ASKER

Oh!...wow

It works! ... Thank you very much. :)