Pointers and References

A pointer holds a memory address. A reference is an alias for an existing variable. Both are how C++ lets one piece of code reach into memory owned by another. They are the two tools you will use most often once functions and objects start sharing data.

Beginners often find pointers intimidating. Don't be. A pointer is just a number — the address of a byte in memory — with a type attached so the compiler knows how to interpret what's there.

A pointer is an address with a type

int  n = 42;
int* p = &n;     // p holds the address of n

After the second line, two variables exist:

• n is an int somewhere on the stack, storing 42.
• p is an int* (read: "pointer to int"), storing the address of n.

You read what a pointer points to with the dereference operator *: *p means "the int at the address held by p."

Two operators do most of the pointer work:

• &x — take the address of x. Type: T* if x is T.
• *p — dereference p to read or write the pointed-to value.

nullptr: the pointer that points to nothing

A pointer that holds the special value nullptr does not point at any object. Dereferencing it is undefined behavior — usually a crash. Initialize every pointer to something (often nullptr) and check before dereferencing.

Older code uses 0 or NULL instead of nullptr. Always use nullptr in modern C++: it has its own type and avoids ambiguities.

References: aliases, not pointers

A reference is a second name for an existing variable. Once bound, it cannot be re-bound to anything else.

int n = 42;
int& r = n;   // r is now another name for n
r = 100;      // modifies n
std::cout << n;  // prints 100

Key differences from pointers:

You use references most often as function parameters (which we covered in the functions chapter) and as return types when you want the caller to be able to modify a member of an object.

When to use which

A rough but reliable rule:

• By value if the type is cheap to copy and you don't need to modify the caller.
• Const reference if the type is expensive to copy and you don't need to modify it.
• Non-const reference if you must modify the caller's object.
• Pointer if the parameter is optional (so it can be nullptr) or if you want to express "I might point at a different object later."
• Smart pointer (std::unique_ptr, std::shared_ptr) when you actually own a heap object. We'll cover these soon.

Pointer arithmetic and arrays

Arrays in C++ live in contiguous memory. You can do arithmetic on pointers to step through them.

Pointer arithmetic moves in steps of the pointed-to type's size: p + 1 advances by sizeof(int) bytes, not by 1 byte. This is exactly what makes array indexing work.

In modern C++ we usually prefer std::vector over raw arrays — it carries its own size, grows itself, and frees itself. Pointer arithmetic is then internal to the implementation, not your daily code.

-> is just (*p). shorthand

When p is a pointer to a struct or class, you access its members with ->:

struct Point { int x; int y; };
Point pt{3, 4};
Point* p = &pt;
std::cout << (*p).x << "\\n";   // works but verbose
std::cout << p->x   << "\\n";   // same thing, idiomatic

Const + pointers: the four shapes

Mixing const with pointers trips up everybody at first. Read right-to-left:

int* p;                  // pointer to int. Can change both.
const int* p;            // pointer to const int. Can't write *p; CAN reassign p.
int* const p;            // const pointer to int. Can write *p; CAN'T reassign p.
const int* const p;      // const pointer to const int. Can change nothing.

The compiler enforces this for you, which is why const everywhere is so valuable: it documents intent and catches mistakes.

Common pointer/reference bugs

Almost every C++ runtime crash is one of these:

A worked example: swap, two ways

We saw swap_ints by reference. Here it is again, both with references and with pointers, so you can compare.

The reference version is simpler at the call site (swap_ref(x, y) versus swap_ptr(&x, &y)) and safer (it can't be null). Reach for references unless you really need to express "this might be absent."

Challenges

Test your understanding

Next: how to ask the operating system for memory you really need — dynamic memory with new, delete, and the modern-C++ tools that automate them.