Pointers & References in C++

Understanding Pointers and References

Suppose x holds 42. How can another part of your program change that exact integer without making a copy? A pointer stores its address; a reference gives the same object another name. Both provide access to the original object, but they behave differently when assigned to.

In Python memory management, names refer to objects whose lifetimes CPython manages through reference counts and garbage collection. A C++ raw pointer does not provide that lifetime management. Understanding the address is only half the job; the object at that address must still be alive.

Key Concepts Covered

Follow x, ptr, and ref through four independently controlled examples. Each step connects an active source line to the values and memory relationships it changes. The diagrams use authored, illustrative addresses and a 4-byte int; they do not execute C++ in the browser.

1int x = 42;2int* ptr = &x;3std::cout << *ptr << "\n";4*ptr = 100;5std::cout << x << "\n";

A reference offers another way to reach the same object. Compare assigning through ref with changing the address stored in ptr.

1int x = 42;2int y = 7;3int& ref = x;4int* ptr = &x;5ref = 100;6ptr = &y;7ref = y;8*ptr = 9;9std::cout << x << " " << ref << " " << y << "\n";

Pointers can also traverse contiguous arrays. Follow the pointer as it advances, then inspect the one-past-the-end boundary.

1int arr[] = {10, 20, 30, 40, 50};2int* ptr = arr;3++ptr;4++ptr;5std::cout << *ptr << "\n";6ptr = arr + 5;  // One past the end; do not dereference.

An address only helps while its object is alive. Delete the heap object below, then see why resetting one pointer leaves the other alias dangling.

1int* ptr = nullptr;2int* alias = nullptr;3ptr = new int(42);4alias = ptr;5delete ptr;6ptr = nullptr;7alias = nullptr;

Deep Dive: Pointer vs Reference

Pointers

int* ptr = &x creates a pointer object and stores the address produced by &x. The expression *ptr designates the pointed-to integer: you can read its value or assign a new one. Changing *ptr changes x; changing ptr changes which object you reach.

The pointer has storage of its own. &ptr is the address of that pointer object, while ptr is the address it holds. A pointer-to-pointer (int**) adds another level of indirection.

References

int& ref = x binds an lvalue reference to x. Reading ref reads x, assigning to ref writes x, and &ref equals &x. The language does not require a reference to occupy a separate storage slot, so the diagram gives the integer two names.

Once bound, the reference cannot be reseated. ref = y assigns the value of y to x; it does not change the binding. A reference has no valid null state, but it can dangle if its object dies. Syntax does not replace lifetime management.

This page focuses on lvalue references (T&). Rvalue references (T&&) support move semantics and forwarding. References to references cannot be declared directly; template substitution and type aliases can produce combinations handled by reference collapsing.

Pointer arithmetic stays within an array

For a T*, adding one advances by one T element, corresponding to sizeof(T) bytes. The explorer uses a 4-byte int as an illustration; the size of int depends on the implementation.

For the five-element array, arr + 5 is a valid one-past-the-end pointer, useful as a loop boundary. It must not be dereferenced. Arithmetic beyond that boundary, or subtraction of pointers into unrelated arrays, is undefined behavior.

Best Practices

Choose the parameter type to express what the caller is allowed to do:

1. Use a reference for a required object. Use T& when the function may modify the caller's object, or const T& for read-only access to an object that would be expensive to copy. Small scalar values are often better passed by value.
2. Use a pointer for an optional object. A documented nullptr state makes absence explicit. Check for null before accessing an optional target.
3. Keep ownership explicit. Prefer scope-bound objects and containers. Use std::unique_ptr for exclusive dynamic ownership, and std::shared_ptr when ownership truly needs to be shared.
4. Keep array bounds available. Prefer range-based loops, containers, or std::span (C++20) when passing a contiguous range. A raw pointer alone does not carry its length.

Raw Pointer Management

The lifetime example shows the essential rule: copying a raw pointer copies an address, without creating an owner or extending the object's lifetime. If your code takes ownership with new, it must eventually release that allocation:

// Manual memory management with raw pointers
int* ptr = new int(42);  // Allocate on heap
*ptr = 100;              // Modify value
delete ptr;              // Must manually free memory
ptr = nullptr;           // Clear this pointer; other aliases still dangle

// Array allocation
int* arr = new int[5];   // Allocate array
delete[] arr;            // Must use delete[] for arrays

Further Reading

• C++ working draft: references
• C++ working draft: pointer arithmetic
• C++ Core Guidelines: resource management

Related concepts