Is it good practice to NULL a pointer after deleting it?

by

Setting a pointer to 0 (which is “null” in standard C++, the NULL define from C is somewhat different) avoids crashes on double deletes.

Consider the following:

Foo* foo = 0; // Sets the pointer to 0 (C++ NULL)
delete foo; // Won't do anything

Whereas:

Foo* foo = new Foo();
delete foo; // Deletes the object
delete foo; // Undefined behavior

In other words, if you don’t set deleted pointers to 0, you will get into trouble if you’re doing double deletes. An argument against setting pointers to 0 after delete would be that doing so just masks double delete bugs and leaves them unhandled.

It’s best to not have double delete bugs, obviously, but depending on ownership semantics and object lifecycles, this can be hard to achieve in practice. I prefer a masked double delete bug over UB.

Finally, a sidenote regarding managing object allocation, I suggest you take a look at std::unique_ptr for strict/singular ownership, std::shared_ptr for shared ownership, or another smart pointer implementation, depending on your needs.

More Related Contents:

  1. determine size of array if passed to function
  2. Testing pointers for validity (C/C++)
  3. NULL vs nullptr (Why was it replaced?) [duplicate]
  4. C++ standard: dereferencing NULL pointer to get a reference? [duplicate]
  5. Checking if this is null
  6. Is there any reason to check for a NULL pointer before deleting?
  7. Can I use if (pointer) instead of if (pointer != NULL)?
  8. dereferencing the null pointer
  9. Why are NULL pointers defined differently in C and C++?
  10. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  11. What is the difference between '.' and '->' when used in array? [closed]
  12. ifstream* Segmentation fault [closed]
  13. A short C++ program about the pointer
  14. C++ Memory Leak Using char *
  15. How to access a local variable from a different function using pointers?
  16. Why should I use a pointer rather than the object itself?
  17. Typedef function pointer?
  18. Is it safe to delete a NULL pointer?
  19. Dynamically allocating an array of objects
  20. Why does int pointer ‘++’ increment by 4 rather than 1?
  21. Checking for NULL pointer in C/C++ [closed]
  22. What does “void *(*)(void *)” mean in C++?
  23. Is pointer comparison undefined or unspecified behavior in C++?
  24. Declaring a pointer to multidimensional array and allocating the array
  25. Why am I able to make a function call using an invalid class pointer
  26. Why do linked lists use pointers instead of storing nodes inside of nodes
  27. Why do some people prefer “T const&” over “const T&”?
  28. Understanding -Weffc++
  29. Safety of casting between pointers of two identical classes?
  30. How can a char pointer be initialized with a string (Array of characters) but an int pointer not with an array of integer? [duplicate]

Leave a Comment