member HBufC

[lokesh_kumar_s]

here is a scenario

scenario 1
i want a member HBufC so i declare it in header file
HBufC* heap;
in cpp file i do following thing
....
heap=HBufC::NewL(14);
....
.....
heap=HBufC::NewL(15);
...
....
heap=HBufC::NewL(11);

delete heap;

does this cause memory leak?


scenario 2
heap=HBufC::NewL(14);
delete heap;
....
.....
heap=HBufC::NewL(15);
delete heap;
...
....
heap=HBufC::NewL(11);
delete heap;

how about this is this correct?

[kiran10182]

Yes, scenario 1 will induce memory leak. Scenario 2 is fine.

[lokesh_kumar_s]

Yes, scenario 1 will induce memory leak. Scenario 2 is fine.

but in scenario 1 at the end i have deleted the heap right. so no pointer variable.

i edited the question i just want to ask you have you saw delete heap; before answering?

[veon1]

Memory is allocated each time when you call NewL();
every time you will have another pointer on heap. In scenario 1 you allocated three blocks and free only one.

I advice you to use CleanUpStack and NewLC methods, it will save a lot of your time.

[symbianyucca]

you definetely do not want to use CleanUpStack with member variables, anyway, with member variables, do set them to NULL after each deletion, so you can avoid double deletions causing nasty Kern-Exec 3 panics.

[kiran10182]

but in scenario 1 at the end i have deleted the heap right. so no pointer variable.

i edited the question i just want to ask you have you saw delete heap; before answering?

Yes, I did read it. In scenario 1, each time to call NewL() , I believe it calls constructor in that code, which will allocate new area on the heap for your object and previously occupied memory will be leaked. Since you are calling delete only once, it will call respective detructor for NewL(11). But for NewL(14) and NewL(15), there is a memory leak.

[veon1]

2symbianyucca: Why not?

As I remember we should push any allocated pointer to the cleanup stack, in case of leave, this memory will be freed.
The only difference - if you intend to use this buffer further (outside the current method) just call CleanupStack::Pop(). If the value is necessary only in the method call CleanupStack::PopAndDestroy().

[lokesh_kumar_s]

you definetely do not want to use CleanUpStack with member variables, anyway, with member variables, do set them to NULL after each deletion, so you can avoid double deletions causing nasty Kern-Exec 3 panics.

Thanks yucca for your answer. But i want to know what is the need of setting the hbuf variable to NULL after each deletion. can you please guide me.

[kiran10182]

But i want to know what is the need of setting the hbuf variable to NULL after each deletion. can you please guide me.

Calling "delete" on already deleted object is undefined. But calling delete on NULL is fine. The following code snippet will give you KERN-EXEC 3.

heap=HBufC::NewL(14);
delete heap;
....
.....
delete heap; // without your knowledge if you try to call delete again on already deleted object. Causes KERN-EXEC 3

But the following code is fine:

heap=HBufC::NewL(14);
delete heap;
heap = NULL;
....
.....
delete heap; // Fine. No KERN-EXEC 3. Deleting NULL pointer is fine.

And the follwing code is fine too:

heap=HBufC::NewL(14);
delete heap;
....
.....
heap=HBufC::NewL(15); // Now "heap" points to some valid address 
delete heap; // Fine. No KERN-EXEC 3

[kiran10182]

As I remember we should push any allocated pointer to the cleanup stack, in case of leave, this memory will be freed.
The only difference - if you intend to use this buffer further (outside the current method) just call CleanupStack::Pop(). If the value is necessary only in the method call CleanupStack::PopAndDestroy().

Cleanupstack will be useful for the automatic varibles which are created on the heap. You really don't need to perform cleanup stack operations on member variables. The following case where cleanupstack will be useful:

void CMyClass::SomeLeavingFunctionL()
{
        CAnotherClass* cl = CAnotherClass::NewL(); // Here cl is an automatic variable created on the heap
        CleanupStack::PushL(cl);
        cl->SomeAnotherLeavingFunctionL(); //If this function leaves then your "cl" will be freed by Cleanupstack
        CleanupStack::PopAndDestroy(cl);
}

[lokesh_kumar_s]

thank you very much kiran. what about for class's object i.e., C type.

is this valid

Cbugger mbug=Cbugger::NewL(_L("mm.txt"));
....
.....
delete mbug;
mbug=NULL;
...
...
delete mbug;

or do i need to create pointer variable like this

Cbugger* mbug=Cbugger::NewL(_L("mm.txt"));
....
.....
delete *mbug;
*mbug=NULL;
...
...
delete *mbug;

[kiran10182]

"C" classes are supposed to be created on the heap. So eventually you end up using pointer variables for them. So if the mbug is your automatic variable then you should use the following:

Cbugger* mbug=Cbugger::NewL(_L("mm.txt"));
....
// if you are going to perform some leaving operation on mbug then you might want to consider pushing it on the cleanupstack
.....
delete mbug; // delete operator works on pointer. And if you have pushed it on the cleanupstack then you should use PopAndDestroy of cleanupstack

[veon1]

2kiran10182:

in this case

...
CAnotherClass* CMyClass::cl
...
void CMyClass::CreateL()
{
        cl = CAnotherClass::NewL(); // Here cl is an automatic variable created on the heap
        CleanupStack::PushL(cl);
        User::Leave(-1);
        CleanupStack::Pop(cl);
}

void CMyClass::~CMyClass()
{
        if (cl) 
           delete cl;
}

It would not be useful?

[kiran10182]

As said: whether you put this way or that way, if cl is a member variable then it won't be useful.

[wizard_hu_]

...
CAnotherClass* CMyClass::cl
...
void CMyClass::CreateL()
{
        cl = CAnotherClass::NewL(); // Here cl is an automatic variable created on the heap
        CleanupStack::PushL(cl);
        User::Leave(-1);
        CleanupStack::Pop(cl);
}

void CMyClass::~CMyClass()
{
        if (cl) 
           delete cl;
}

It would not be useful?

No, it would not. This code is overcomplicated and wrong at the same time.
Overcomplicated: why would you want to put anything on the Cleanup Stack, which could not be lost anyway?
Wrong: delete (including delete by Cleanup Stack) does not NULL the pointer, so your "if(cl)delete cl;" would result in a KERN-EXEC 3. Though this "if(cl)delete cl;" sometimes appear even in official examples, it makes no sense. You can freely delete a NULL pointer at any time, and it does not prevent erroneous double deletions. "if(cl)" checks if cl is NULL or not, it does not say anything about its validity - C/C++ is not Java/C#.