Deleting an object when multiple pointers are pointing to it?

Question

I've been told that when if I have multiple pointers pointing to the same object, I cannot delete it normally (using the delete keyword). Instead, I've been told that I need to set the pointers to NULL or 0.

Given I have:

ClassA* object = new ClassA();
ClassA* pointer1 = object;
ClassA* pointer2 = object;

So to delete pointer1 and pointer2, do I need to do the following?

pointer1 = 0;
pointer2 = 0:

Once I've set it to NULL, do I still need to use the keyword delete? Or is just setting it to 0 good enough?

Answer 1

Whenever you new an object, you need to delete it, free'ing the memory

ClassA* object = new ClassA();

delete object; // Free's the memory you allocated.

The point of setting your pointers to NULL is to stop dereferencing pointers that are invalid

object = NULL;

This is done so that tests can be performed before attempting a dereference:

if(object != NULL)
{
  object->SomeMethod(); // We can assume it's safe to use the pointer.
}

Also note that you can delete the memory from any pointer that points to it.

ClassA* object = new ClassA();
ClassA* pointer1 = object;
ClassA* pointer2 = object;

delete pointer1; 

object, pointer1, and pointer2 now all point to memory that has already been released, and unless they will be redefined, they should all be set to NULL.

Answer 2

The rule is You must call delete as many times you called new.
So if you allocated memory only once you need to deallocate it only once too.

You can just be better off using shared_ptr to avoid this manual memory management, wherein the smart pointer itself will deallocate the memory once no pointer is pointing to it.

Answer 3

You just have to make sure that you don't use the object anymore after deleting it. It doesn't matter whether you have pointers pointing to it, but you need to know that these pointers are now invalid. Setting them to nullptr is merely a way to get a sure crash when you use them; using invalid pointers may or may not cause a crash, but it will eventually cause obscure problems that are difficult to trace.

However, if you have "live" pointers to the object when you delete it, that MIGHT indicate a problem in your code. Usually, an object gets deleted when nobody needs it anymore, which means there SHOULD be no pointers or other references to it. This is not a hard rule, of course.