Pointers & References

Pointers

A pointer holds the address of another object. Two operators do the work: & takes an address, * dereferences (reads/writes the pointed-to value).

int x = 10;
int* p = &x;        // p holds the address of x
*p = 20;            // write through the pointer; now x == 20
std::cout << *p;    // read through the pointer; prints 20
p = nullptr;        // points to nothing. Dereferencing this is UB.

Always initialize pointers. An uninitialized pointer holds garbage, and dereferencing it is undefined behavior. Use nullptr (never NULL or 0) to mean "points to nothing," and check before dereferencing.

References

A reference is an alias — another name for an existing object. Unlike a pointer, it cannot be null, cannot be reseated to another object, and needs no dereference syntax.

int x = 10;
int& r = x;      // r is another name for x. Must bind on creation.
r = 20;          // changes x directly; now x == 20

Rule of thumb: use a reference when the thing always exists and you never need to rebind. Use a pointer when it can be null or needs to point at different objects over time. In the order book, an order's location within a price level is naturally a pointer (it can be absent); a function that must operate on an existing book takes a reference.

The three consts

This is a guaranteed interview question. Read const from right to left around the *.

const int* p1;        // pointer to const int: can't change *p1, CAN change p1
int* const p2 = &x;   // const pointer to int: CAN change *p2, can't change p2
const int* const p3 = &x; // const pointer to const int: can't change either

• const int* p1 — the data is const. You can point p1 elsewhere, but you can't modify what it points to.
• int* const p2 — the pointer is const. You can modify the pointed-to value, but p2 is stuck pointing where it started.
• const int* const p3 — both are locked.

Arrays and pointer arithmetic

An array's name decays to a pointer to its first element. Adding 1 to a pointer advances it by one element, not one byte — the compiler scales by sizeof the type.

int arr[4] = {10, 20, 30, 40};
int* p = arr;        // points to arr[0]
std::cout << *(p + 2);  // prints 30 — advanced by 2 ints
std::cout << p[2];      // identical: p[2] means *(p + 2)

Dangling pointers

A dangling pointer refers to memory that no longer holds a valid object — because it was freed, or because it went out of scope.

int* bad() {
    int local = 42;
    return &local;   // returns address of a stack variable that dies NOW
}                     // caller gets a dangling pointer — UB to use it

Returning the address of a local, keeping a pointer after delete, or holding a pointer into a vector that later reallocates (Module 07) — all produce dangling pointers. Recognizing them on sight is exactly what the debugging round tests.