NULL pointer is the same as deallocating it?

Question

I was working on a piece of code and I was attacked by a doubt: What happens to the memory allocated to a pointer if I assign NULL to that pointer?

For instance:

A = new MyClass();

{...do something in the meantime...}

A = NULL;

The space is still allocated, but there is no reference to it. Will that space be freed later on, will it be reused, will it remain on stack, or what?

Answer 1

This is a classic leak. As you say, the memory remains allocated but nothing is referencing it, so it can never be reclaimed - until the process exits.

The memory should be deallocated with delete - but using a smart pointer (e.g. std::auto_ptr or boost::shared_ptr (or tr1::shared_ptr) to wrap the pointer is a much safer way of working with pointers.

Here's how you might rewrite your example using std::auto_ptr:

std::auto_ptr a( new MyClass() );

/*...do something in the meantime...*/

a.reset();

(Instead of the call to reset() you could just let the auto_ptr instance go out of scope)

Answer 2

Under most circumstances, that will cause a memory leak in your process. You have several options for managing memory in C++.

1. Use a delete to manually free memory when you're done with it. This can be hard to get right, especially in the context of exception handling.

2. Use a smart pointer to manage memory for you (auto_ptr, shared_ptr, unique_ptr, etc.)

3. C++ does not come with a garbage collector, but nothing prevents you from using one (such as the Boehm GC) if you want to go down that route.