Addresses and Pointers

Memory is addressed — and C++ lets you use the addresses

This unit exists because the structures interviews love — linked lists, trees, graphs — are built from values that refer to other values, and in C++ that referring mechanism is explicit. It is also the layer that finally explains crashes: segmentation faults, dangling references, and even Python's object model all become concrete once you can see addresses.

The actual hardware rule first: RAM is byte-addressable. Every byte of memory has a unique number, its address, and the CPU reads and writes data by giving that number. While your program runs, every variable therefore lives at some address. (If a mental image helps: a gigantic row of numbered one-byte boxes.) An int occupies 4 consecutive bytes, and "the address of x" means the address of its first byte.

C++ lets you work with addresses directly:

• &x is the address-of operator: the address where x lives. (Same symbol as reference declarations, different meaning by context.)
• A pointer is a variable whose value is an address. int* p declares p as "pointer to int".
• *p is the dereference operator: go to the address stored in p and use the int that lives there.

int x = 42;
int* p = &x;   // p now holds x's address

std::cout << *p;   // 42, read x through p
*p = 99;           // write through p
std::cout << x;    // 99, x itself changed

Python hides all of this: every Python name is secretly a pointer-like handle managed for you. C++ hands you the raw mechanism.

nullptr, and why pointers exist at all

A pointer that points at nothing should be set to nullptr:

int* p = nullptr;
if (p != nullptr) { std::cout << *p; }   // guard before dereferencing

Dereferencing a null (or otherwise invalid) pointer is undefined behavior, usually a crash. This is the sharpest edge in C++.

Why does the language keep such a dangerous tool?

• Dynamic memory: memory created at run time (unit 6) is reachable only through a pointer.
• Data structures: linked lists, trees, and graphs are nodes that point at other nodes.
• Cheap sharing: passing an 8-byte address instead of copying a large object (references, from lesson 4-2, are a tamer packaging of the same idea).
• Arrays: an array's name is essentially the address of its first element, as you will see next lesson.