An explanation of Rust pointers, assuming familiarity with C or Go, but seeking the Rust way of thinking.

The Core Concept: The Address vs. The Rules

In C or Go, a pointer is like a scrap of paper with a house address on it.

• If you copy that pointer, you just write the address on another scrap of paper.
• Now two people have the address. They can both go to the house and rearrange the furniture at the same time.
• If the house is demolished but you still have the scrap of paper, you might try to enter a house that doesn't exist anymore (segfault).

In Rust, a pointer is still a memory address, but it comes attached to a legal contract.

Rust doesn't just care where the data is; it cares who is allowed to touch it and for how long.

1. References: &T and &mut T

These are the most common "pointers" in Rust. They are purely for Borrowing.

• Concept: You are lending your house key to a friend. You still own the house. They just get access for a specific time.
• C Equivalent: A standard pointer int *p, but the compiler tracks the scope of the variable p points to.
• Go Equivalent: Passing a pointer to a function.

The Rust Twist (The Rules)

• &T (Shared Reference): You can give this to many people. They can all look at the data, but nobody can change it.
• &mut T (Mutable Reference): You can only give this to one person at a time. While they have it, not even you can look at the data. This prevents race conditions (two people writing at once).

House Analogy

&T — Read-Only Keycard: