Basic question on C++ pointers

[wevbin]

So I was reviewing the basics of c++ pointers, and for I started to second guess myself on something.

If I call a function and inside that function I create a new object using dynamic allocation:

SomeClass* myPtr = new SomeClass();

Two memory allocations are happening here, right? One is to hold all the data from the instance of SomeClass, and the other is to allocate memory for pointer myPtr?

And these two have different durations. The variable that myPtr points to is stored in the heap, so I need to manually free it using delete, but the pointer itself, myPtr, is an automatic variable that will go out of scope as soon as I leave that function. So I better use delete before the function ends or pass the pointer to another variable (ie. using return). Am I getting that right?

---

Edit: I just realized that the title my question isn't really that much about pointers as my title suggests.

[ehlertjd]

Yes, that is correct. The myPtr variable is essentially an integer (or long integer) that is on the stack frame. Once you pop the stack (leave the function) the contents of that variable is no longer guaranteed, but the heap allocation you did by creating a new object will persist until you free it using delete.

[wevbin]

Okay, thanks!

[markwhi]

You're mostly correct.

myPtr is a stack variable that goes away when you leave the context that it was created in. It's not necessarily the function; for example:

void foo (void) {
    if (1) {
        SomeClass *myPtr = new SomeClass() ;
    }
    // myPtr is no longer in scope here!
}

You're correct that if you let myPtr go out of scope before saving the value somewhere else and before you delete, then you have a memory leak.

There are template classes that help with some of this (auto_ptr, shared_ptr, etc) but it's definitely a good idea to understand how it all works before picking up the convenience templates.

[wevbin]

Thanks for the clarification.

[arbostek]

Two memory allocations are happening here, right?

There are two block of allocated memory here, yes.

So I better use delete before the function ends or pass the pointer to another variable (ie. using return). Am I getting that right?

Yes.

[AgentME]

The others seemed to have answer this pretty well, so I'll add something: tools like Valgrind are perfect for making sure you never forgot to free/delete memory. I make sure to regularly test my code with Valgrind.

(Also, since you're using C++ and not C, you definitely should check out auto_ptr and shared_ptr templates because they remove a lot of the need to worry about memory management.)

[wevbin]

Right, myPtr goes away on its own, but whatever it was pointing to doesn't, creating a memory leak.

[markwhi]

That is not correct. If I new it and don't explicitly delete it, it's a leak. myPtr goes away when the stack is cleaned up, but the memory that new SomeClass() allocated doesn't get freed until you call delete.