Dangling Pointers in C++

A dangling pointer is a pointer that still holds the address of memory that is no longer valid — because the memory has been freed (deleted) or because the variable it pointed to has gone out of scope. The pointer itself still "looks" valid (it holds some address), but using it to read or write data is undefined behavior, since that memory may have been reused for something else entirely.

A pointer becomes dangling in a few common situations: (1) after calling delete on the memory it points to, without also resetting the pointer; (2) when it points to a local (stack) variable inside a function, and that function returns, destroying the variable while the pointer that referenced it still exists elsewhere; and (3) when multiple pointers point to the same heap block and one of them deletes it, leaving the others dangling. The danger is that a dangling pointer's address is not automatically invalidated or marked — the pointer still contains a real-looking address, and dereferencing it (*p) does not necessarily crash immediately. Instead it produces undefined behavior: it might silently read/write garbage data, corrupt unrelated memory that has since been reused, or crash unpredictably — bugs from dangling pointers are notoriously hard to track down because the failure can appear far away from the actual mistake. The standard defense is discipline: immediately set a pointer to nullptr after delete-ing it, never return the address of a local stack variable from a function, and avoid having multiple raw pointers independently own and free the same memory. Checking if (p != nullptr) before use is only effective if the pointer was properly nulled out after deletion — it does nothing to protect against a dangling pointer that was never reset.