# dangling pointer

## ⚙️ The Truth: Memory isn’t erased immediately

When you write:

```plaintext
int *p = new int(5);
delete p;
cout << *p;   // still prints 5 😮
```

This is called **undefined behavior** —  
but “undefined” does **not** mean it will always crash.  
It just means the compiler is free to do **anything**:

* Sometimes it prints `5`
    
* Sometimes it prints **garbage**
    
* Sometimes it **crashes**
    
* Sometimes it **does nothing**
    

---

## 🧠 Why does it still print `5`?

When you do `delete p`:

* You tell the system: “this memory is free; you can reuse it later.”
    
* But the OS **does not immediately erase or overwrite** that memory.
    
* So, for a short time, the **old value (5)** still physically exists in RAM.
    

So when you do:

```plaintext
cout << *p;
```

You’re still reading from that same memory address —  
and since it hasn’t been reused yet, it prints `5`.

---

### 🔍 Memory Diagram

```plaintext
Before delete:
   Address 1000 → 5
   p = 1000

After delete:
   Address 1000 → marked as "free"
   Value (5) may still exist temporarily
   p = 1000  (dangling)
```

👉 That’s why you *still* get `5` — but it’s just **luck**, not correct behavior.

---

## 💥 Why it’s dangerous

Because later:

* Some other variable or program may reuse that same memory (address 1000).
    
* Then `*p` will read **wrong data** or even **crash**.
    

So, the pointer still *points* to that memory,  
but that memory **no longer belongs to you**.

---

## 🧩 Real-Life Example

Imagine:

* You have a house (address 1000).
    
* You move out and give the house back to the landlord (`delete`).
    
* The old furniture (value = 5) is **still there** for now.
    
* If you sneak back in and look, you might still see it! 😄  
    But once someone new moves in, everything changes —  
    and you can’t trust that house anymore.
    

That’s exactly what happens with a **dangling pointer**.

---

## ✅ Safe Way

Always set pointer to `NULL` (or `nullptr`) after deleting:

```plaintext
int *p = new int(5);
delete p;
p = NULL;  // or p = nullptr;

if (p != NULL)
    cout << *p;
else
    cout << "Pointer is invalid now";
```