Direct Memory Manipulation and Pointers in C++

Learning objectives

• Explain virtual address space and why a pointer value is an address in a process.
• Use & and * to take addresses and dereference pointers safely.
• Distinguish pointers from references and choose the clearer API type.
• Read const-correct pointer declarations.
• Identify pointer bugs such as wild pointers, dangling pointers, double delete and out-of-bounds arithmetic.

Key vocabulary before you start

Example: address-of and dereference

This example mirrors the supplied pointer lesson and shows how a pointer can observe and mutate another object.

int y = 5;
int* x = nullptr;
x = &y;      // x stores the address of y
int v = *x;  // dereference: read y through x
*x = 42;     // dereference: write y through x

Visual model: pointer validity states

Before dereferencing a pointer, classify its state rather than trusting the syntax.

Virtual vs physical memory

A process works with a virtual address space. The operating system and hardware memory-management unit map those virtual addresses onto physical memory as needed.

A pointer value is meaningful inside the process that owns that address space. It is not a portable, universal physical location.

This abstraction lets programs treat memory as a large addressable space while the system manages protection, mapping and paging.

The unary operators & and *

&object gives the address of an object. *pointer dereferences a pointer to access the object it points to.

Dereferencing is only valid if the pointer points to a live object of the right type.

Use parentheses and naming when pointer expressions become hard to read. A confusing pointer expression is a maintenance risk.

int y = 5;
int* p = &y;
std::cout << *p << '\n';
*p = 99;
std::cout << y << '\n';

Initialisation matters: nullptr, dangling and wild pointers

An uninitialised pointer contains an indeterminate value. Dereferencing it is unsafe.

Use nullptr to represent no target. It is explicit, comparable and safer than leaving a pointer wild.

A dangling pointer once pointed to a valid object, but that object's lifetime has ended.

int* p;          // wild: do not use
int* q = nullptr; // safe empty state

int* d = nullptr;
{
    int local = 7;
    d = &local;
}
// d is now dangling; do not dereference it

Pointers vs references

A reference is usually the clearer API when an object is required. It cannot be reseated and does not represent null.

A pointer is appropriate when null is a meaningful state, when reseating is needed, or when interfacing with APIs that use pointer semantics.

Use the type to communicate intent. int& says required object; int* says optional or low-level address semantics.

void set_to_42(int& r) {
    r = 42;
}

void maybe_set(int* p) {
    if (p) *p = 42;
}

Const-correctness with pointers

const int* means pointer to const int: you cannot modify the int through that pointer.

int* const means const pointer to int: the pointer cannot be reseated, but the pointed-to int can be modified.

const int* const means both the pointer and pointed-to int are const through that name.

int value = 1;
const int* readOnly = &value; // cannot write *readOnly
int* const fixedTarget = &value; // cannot reseat fixedTarget
const int* const fixedReadOnly = &value; // neither through this name

Arrays and pointer arithmetic

Array names can decay to pointers in many expressions, and pointer arithmetic advances by elements, not bytes.

This is powerful but easy to misuse. Indexing past the valid range is undefined behaviour.

Prefer std::array, std::vector, iterators and ranges unless raw pointer arithmetic is required for a clear systems-level reason.

int values[3] = {10, 20, 30};
int* p = values;
std::cout << *p << '\n';
++p;
std::cout << *p << '\n';

Dynamic memory: avoid raw new and delete in modern C++

Raw new and delete create ownership obligations that are easy to break across returns, exceptions and multiple code paths.

Use containers for sequences and smart pointers when heap ownership is genuinely required.

The best heap allocation is often the one you do not write at all.

std::vector<int> values(100);
values[0] = 42;

auto p = std::make_unique<int>(42);
std::cout << *p << '\n';

Printing addresses

Printing addresses can help trace aliasing and lifetime in a debugging exercise.

Cast object pointers to const void* for a clear address display.

Do not build program logic around printed addresses. Address values vary between runs and environments.

int value = 5;
std::cout << static_cast<const void*>(&value) << '\n';

Common pointer bugs

The classic pointer bugs are uninitialised pointers, dangling pointers, use-after-free, double delete, out-of-bounds access and invalidated pointers into containers.

Many bugs are not visible immediately. They corrupt state and fail later, which is why sanitizers and small repros matter.

The professional default is to remove raw pointer ownership from ordinary application code.

std::vector<int> v{1, 2, 3};
int* p = &v[0];
v.push_back(4); // may reallocate
// p may now be invalid

Applied case lab

Applied task: explain the pointer

Practise tracing pointer state and replacing unsafe pointer APIs.

Stage 1: read and classify

int y = 5;
int* x = nullptr;
x = &y;
int a = *x;
*x = 99;

After `x = &y`, `x` validly points to `y`. `a` becomes 5. `*x = 99` mutates `y`, so `y` becomes 99.

Stage 2: trace or repair

void write_value(int* out, int v) {
    if (out) *out = v;
}

void write_value(int& out, int v) {
    out = v;
}

Stage 3: justify the design

int* make_value(int v) {
    return new int(v);
}

std::unique_ptr<int> make_value(int v) {
    return std::make_unique<int>(v);
}

int make_value_simple(int v) {
    return v;
}

Quick checks

AI-augmented practice notes

Use these as prompts for disciplined support, not as permission to outsource judgement.

Assessment tasks

1. Annotate a pointer-heavy function with owner, target lifetime and nullability for every pointer.
2. Refactor one pointer output parameter to a reference or return value.
3. Replace one raw dynamic array with std::vector or std::array.

Judgement questions