Pointers and References

Reference basics

int value = 10;
int& ref = value;
ref = 20;

Changing ref changes value because they refer to the same object.

Pointer basics

int value = 10;
int* ptr = &value;
*ptr = 20;

A pointer stores an address. Dereferencing with *ptr means "follow that address to reach the object".

Null pointers

Use nullptr, not NULL or 0.

int* ptr = nullptr;

When to use what

• Use references for required aliases
• Use pointers for optional objects or reseating
• Use smart pointers for ownership

Signature examples

void rename(std::string& name);
void print(const std::string& name);
void maybe_use(const Widget* widget);
void take_owner(std::unique_ptr<Widget> widget);

These four signatures communicate four different contracts: mutate required object, read required object, observe optional object, and transfer ownership.

Example

void increment(int& x) {
    ++x;
}

void increment_if_present(int* x) {
    if (x) {
        ++*x;
    }
}

The reference version says the caller must provide a valid object. The pointer version says absence may be allowed and must be handled.

Warning signs

• Dangling pointers
• Double delete
• Using a pointer after the object lifetime ends

Dangling reference example

const std::string& bad_name() {
    return std::string{"temporary"};
}

This returns a reference to an object that is destroyed immediately, which makes later use undefined behavior.

Pointer invalidation example

std::vector<int> values{1, 2, 3};
int* first = &values[0];
values.push_back(4);

If the vector reallocates, first may no longer point to a valid element. This is one of the most common real-world pointer bugs in ordinary container code.

Raw ownership bug shape

Widget* widget = new Widget();
delete widget;
// widget is now dangling

Once an object is deleted, any remaining pointer value is only useful as a thing to overwrite or set to nullptr. It is no longer a safe handle to the object.

Ownership vs observation

Pointers and references often mean "I can access this object", not "I own it". In modern C++, ownership should usually be represented by:

• stack objects
• std::unique_ptr
• std::shared_ptr when shared ownership is truly required

If you only need to read or mutate an object during one call, use a reference, pointer, std::span, or std::string_view instead of reaching for a smart pointer.

References are safer than pointers for required inputs because they cannot be null and they make that guarantee part of the function signature.

const correctness

void print(const std::string& text);
void mutate(std::string& text);

When you add const accurately, both humans and the compiler get a stronger picture of what a function may change.

Safer view types

Modern C++ often replaces raw pointer-and-length pairs with std::span<T> and raw C strings with std::string_view.

void process(std::span<const int> values);
void greet(std::string_view name);

These types still do not own the data, but they express the shape of the borrowed input more clearly than raw pointers alone.

Quick rule of thumb

• required object: reference
• optional object: pointer
• owning heap object: smart pointer
• non-owning contiguous sequence: std::span
• non-owning text: std::string_view

Practical API comparison

void set_title(std::string& text);
void maybe_log(const Logger* logger);
void take_buffer(std::unique_ptr<Buffer> buffer);

Read these as contracts: required mutable object, optional observer, and ownership transfer.