07 Pointers and Memory Basics

1. What pointers represent

A pointer is an object whose stored value provides indirect access to another entity. Depending on its value and type, it can identify an object, identify a function, designate a permitted position one past an array, or represent no target at all. A pointer does not automatically own or extend the lifetime of what it identifies.

Addresses and types

An object occupies storage while it is alive. The address-of operator & obtains a pointer to an object or function. For example, if score is an int, then &score has type int*, meaning pointer to int. The pointer can be copied, inspected, or passed to a function. Its printed representation is implementation-dependent.

The pointer's type matters because it describes how the pointed-to storage is interpreted. A pointer to int is not interchangeable in meaning with a pointer to an unrelated object type merely because both store address-like values.

Takeaway: A pointer is an indirect access path, not automatically an owner of the object at the end of that path.

2. Addresses, indirection, and validity

The dereference operator * accesses the object designated by a valid pointer. If p points to score, then reading *p reads score, and assigning to *p changes score itself. The pointer and the object are different entities, but dereferencing connects an expression to the pointed-to object.

The relationship between & and *

The address-of operator and dereference operator often act as conceptual opposites. If p was formed from &value and remains valid, then *p designates value, and taking the address again gives back the pointer. In notation, this relationship can be expressed as $\&(*p) = p$ for a suitable valid pointer.

A pointer must be valid before it is dereferenced. Dereferencing a null pointer, an uninitialized pointer, a dangling pointer, or a pointer outside the permitted object or array range can cause undefined behavior. The language does not prescribe what the program must do in that situation.

Takeaway: Dereferencing is powerful because it can read or modify an existing object, but it is safe only when the pointer's target and lifetime are valid.

3. Pointer declarations and constness

The * in a declaration belongs to the declarator. This distinction is important when several variables are declared together. In int* first, second;, only first is a pointer; second is an ordinary int. Writing separate declarations is usually clearer.

Constness has two possible targets

In const int* p, the pointed-to integer cannot be changed through p, but p can be changed to point elsewhere. In int* const p, the pointer itself cannot be redirected, but the pointed-to integer can be changed through p. In const int* const p, neither the pointer nor the pointed-to integer can be changed through that declaration.

An uninitialized pointer contains an indeterminate value and must not be dereferenced. Initialize a pointer before use, commonly with nullptr when no object is currently available.

The type std::nullptr_t is the type of nullptr. A null pointer can be compared with another pointer or tested in a condition. A condition that confirms a pointer is non-null is useful, but it does not prove that the pointer is non-dangling, correctly aligned, or within a valid array range.

Takeaway: Read a pointer declaration from its declarator, and determine separately whether const applies to the pointer, the pointed-to object, or both.

4. Null pointers and safety checks

A null pointer represents the absence of an object or function target. Modern C++ uses nullptr for this purpose because its type clearly communicates pointer intent and avoids some overload ambiguities associated with integer zero and NULL.

Testing before access

A nullable pointer can be checked before dereferencing it. If p is non-null, an expression such as *p may be safe with respect to nullness, but other requirements still apply: the target must be alive, suitably aligned, of a compatible type, and within the permitted object or array range.

A non-null pointer may become a dangling pointer when its target goes out of scope, is destroyed, or is otherwise no longer available. The pointer value can remain stored even though the object it once identified has ceased to exist.

Takeaway: nullptr answers only the question “does this pointer have a target value?” It does not answer every question about whether access is valid.

5. Arrays and pointer arithmetic

Pointer arithmetic is defined primarily for pointers to elements of the same array. If p points to element i, then p + n can designate element i + n when that resulting position is an element of the same array or the permitted boundary immediately after it. Advancing a pointer does not move by one byte; for a pointer to T, adding 1 advances by one T object according to the array layout.

The one-past-the-end pointer is useful as a boundary marker. It may be compared with a pointer to an array element and may participate in subtraction, but it must never be dereferenced. Subtracting two pointers is defined when they point into the same array, including its one-past-the-end position. The result has type std::ptrdiff_t and represents the number of elements between them.

Arithmetic that leaves the valid array range, other than forming the one-past-the-end pointer, is invalid. Pointers to unrelated objects must not be subtracted from one another.

Walking through an array

For an array containing four integers, a pointer initialized to the first element can be incremented until it equals a pointer formed at the one-past-the-end position. The loop should test the boundary before dereferencing the current pointer. This pattern visits every element without dereferencing the boundary pointer.

Takeaway: Keep pointer arithmetic tied to one array, and treat the one-past-the-end position as a boundary rather than an element.

6. Arrays, functions, and lifetime

An array-to-pointer conversion occurs in most expressions, turning an array into a pointer to its first element. This explains why an array can initialize a pointer and why an indexed expression can be understood through pointer arithmetic: values[i] is equivalent in effect to *(values + i).

An array and a pointer are nevertheless different types. An array retains its complete extent in contexts such as sizeof(values), whereas a pointer stores only a pointer value and does not contain the array length. Consequently, a function that receives a pointer to an array's first element generally needs a separate size argument, a reference to an array when its exact size matters, or an appropriate standard-library view or container.

Passing pointers to functions

A function receives a copy of a pointer when a pointer is passed by value. Both the copied pointer and the caller's pointer can identify the same object, so assigning through the parameter, such as changing *value, can modify the caller's object. Reassigning the local parameter itself does not redirect the caller's pointer.

If a function must change the caller's pointer, it can receive a reference to a pointer, as in int*&, or use another explicitly chosen interface. A function pointer has a type that includes the return type and parameter list. It can refer to a function and can be called to select an operation.

Lifetime and ownership

A pointer does not extend an object's lifetime. Returning the address of a local variable is invalid because the local object is destroyed when the function returns, leaving a dangling pointer. In ordinary C++, raw pointers are usually clearest as non-owning access paths unless a specific ownership convention is documented. Use references when an existing object is required and null is not a valid input; use standard containers and smart pointers when ownership must be represented.

Practical checklist

• Initialize pointer variables, commonly with nullptr when there is no target.

• Dereference only a pointer to a live, correctly aligned, compatible object.

• Check nullable parameters before dereferencing them.

• Keep an array pointer together with the valid element count.

• Use arithmetic only within one array and its one-past-the-end position.

• Prefer references for required, non-null objects.

• Use an ownership-aware type when the pointer is responsible for managing lifetime.

Final takeaway: Safe pointer programming depends on keeping four facts aligned: the pointer's type, the target's lifetime, the permitted range, and whether the pointer merely observes an object or owns it.