Pointers, the stack and the heap

Memory and addresses

Your computer's memory is a long row of numbered bytes. The number of a byte is its address. Every variable lives at some address. A pointer is a variable whose value is an address: it "points to" another variable.

int seats = 72;
int* p = &seats;        // p holds the address of seats

std::cout << p << '\n';     // an address like 0x7ffd5e8c (changes each run)
std::cout << *p << '\n';    // 72: the value at that address
*p = 60;                    // change seats through the pointer
std::cout << seats << '\n'; // 60

nullptr and checking before use

int* p = nullptr;      // points to nothing
if (p != nullptr) {
    std::cout << *p;
}
// *p here would be undefined behaviour, usually a crash ("Segmentation fault")

References versus pointers

Rule of thumb: use a reference when something must always exist; use a pointer when "nothing" is a valid answer, or when you need to point at different things over time.

The stack and the heap

Local variables live on the stack: memory that is set up automatically when a function starts and cleaned up when it ends. It is fast but limited in size. The heap (also called the free store) is a big pool of memory you request while the program runs, for data whose size you only know at run time or that must outlive the function that made it.

int* marks = new int[5]{70, 80, 90, 60, 85};   // ask the heap for 5 ints
std::cout << marks[2] << '\n';                 // 90
delete[] marks;                                // give it back (new[] needs delete[])

int* one = new int(42);
delete one;                                    // new needs delete

Pointer arithmetic, briefly

int a[3] = {10, 20, 30};
int* p = a;            // an array name turns into a pointer to its first item
std::cout << *(p + 1); // 20, same as a[1]

Common mistakes

• Declaring int* a, b; thinking both are pointers. Only a is; b is a plain int. Declare one per line.
• Using an uninitialised pointer (int* p; *p = 5;): it points at a random place.
• Returning the address of a local variable: it dies when the function returns (a dangling pointer).
• Mixing new[] with delete (without []), which is undefined behaviour.