What happens to the pointer itself after delete? [duplicate]

by

The pointer itself does have an address and the value. The address of the pointer does not change after you perform delete on it. The space allocated to the pointer variable itself remains in place until your program releases it (which it might never do, e.g. when the pointer is in the static storage area). The standard does not say what happens to the value of the pointer; all it says is that you are no longer allowed to use that value until you assign your pointer a valid value. This state of the pointer is called dangling.

In your program, the pointer ptr is dangling after delete has completed, but before the ptr = NULL assignment is performed. After that it becomes a NULL pointer.

The pointer it self is placed on stack or heap?

Pointer variable is a regular variable. Its placement follows the same rules as the placement of other variables, i.e. you can put a pointer in a static area, in an automatic area (commonly known as “the stack”) or in the dynamic memory (also known as “the heap”). In this case, you allocate a pointer to a pointer:

TheObject **ptrPtr = new TheObject*; // The pointer to a pointer is on the stack
*ptrPtr = new TheObject;             // The pointer to TheObject is in the heap
delete *ptrPtr; // The space for TheObject is released; the space for the pointer to TheObject is not
delete ptrPtr;  // Now the space for the pointer to TheObject is released as well
// The space for the pointer to pointer gets released when ptrPtr goes out of scope

More Related Contents:

  1. How to deal with c-string pointers [closed]
  2. Regular cast vs. static_cast vs. dynamic_cast [duplicate]
  3. Is segmentation fault actual undefined behavior when we refer to a non-static data-member
  4. Return array in a function
  5. Are arrays Pointers? [duplicate]
  6. Are there benefits of passing by pointer over passing by reference in C++?
  7. NULL vs nullptr (Why was it replaced?) [duplicate]
  8. What can I use instead of the arrow operator, `->`?
  9. How to avoid memory leaks when using a vector of pointers to dynamically allocated objects in C++?
  10. Determine the size of a C++ array programmatically?
  11. What is the ‘this’ pointer?
  12. difference between a pointer and reference parameter?
  13. C++ Is it possible to determine whether a pointer points to a valid object?
  14. Pointers in c++ after delete
  15. How are iterators and pointers related?
  16. Difference Between *(Pointer + Index) and Pointer[]
  17. Is there any reason to check for a NULL pointer before deleting?
  18. What is the purpose of allocating a specific amount of memory for arrays in C++?
  19. How to know if a pointer points to the heap or the stack?
  20. Is it legal to compare dangling pointers?
  21. Why not use pointers for everything in C++?
  22. Could I ever want to access the address zero?
  23. How to make an array with a dynamic size? General usage of dynamic arrays (maybe pointers too)? [closed]
  24. Dereferencing deleted pointers always result in an Access Violation?
  25. Difference between const. pointer and reference?
  26. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  27. What does ‘**’ mean in C?
  28. What is the proper way to return an object from a C++ function?
  29. Assign a string literal to a char* [duplicate]
  30. Both asterisk and ampersand in a parameter

Leave a Comment