C has a quirk that trips up beginners but powers complex systems. You can point dozens of pointers at the same memory address.
Consider a simple integer i. You can declare three pointers—p, q, and r —and link them all to it.
This isn’t magic. It’s just address copying. When you write r = p, the compiler copies the address held by p into r. The same happens with q.
Now i has four names. It is i. It is *p. It is *q. It is *r.
There is no hard limit on this. You can have hundreds of pointers referencing the same chunk of RAM. Each one is a distinct variable in your code, but they all resolve to the exact same location in memory.
This is why changes made through one pointer affect all others. Modify *p? The value at that address changes for q and r too. It’s a direct view into the same data.
Why does this matter? Because it allows aliasing. Your program can look at the same data through different lenses. One pointer might treat it as a struct. Another might treat it as a raw byte array. The data doesn’t change. The interpretation does.
This flexibility is powerful. It’s also where bugs hide. If you lose track of which pointer is where, you might overwrite data you didn’t mean to. But for now, just remember: pointers are just addresses. And addresses can be shared.
