C++ References, Pointers, and Const

A value parameter receives an independent object. A reference parameter names the caller's object. A pointer parameter receives an address value and can be checked, copied, or changed to point elsewhere. These choices communicate different contracts.

Copying is often exactly right for small values and owned snapshots. Borrowing avoids a copy but ties use to another object's lifetime. Do not reach for pointers solely to appear efficient; first state ownership, optionality, and mutation.

A reference must bind to an object when initialized. Changes through a non-const reference affect that object. A const reference allows observation without mutation and can bind to temporary values for a limited lifetime.

References do not extend every lifetime and do not own storage. Returning a reference to a local object is invalid. Storing a reference beyond the provider's lifetime also dangles, even when the type compiled cleanly.

#include <iostream>

void add_bonus(int& score, int bonus)
{
  score += bonus;
}

int main()
{
  int score{80};
  add_bonus(score, 5);
  std::cout << score << '\n';
}

A pointer stores an address or nullptr. Dereferencing with * accesses the pointed-to object, so a nullable pointer must be checked first. Taking an address with &object does not transfer ownership.

Pointer arithmetic is valid only within carefully defined array ranges and is rarely needed in beginner application code. Standard containers, iterators, spans, and algorithms express most sequence work more safely.

const int* pointer points to an int that cannot be modified through that pointer. int* const pointer is a pointer value that cannot be reseated. const int* const applies both restrictions. Read declarations from the name outward and use aliases when a type becomes difficult to read.

Const correctness makes interfaces more useful: a function accepting const Widget& can receive both const and non-const objects. It also prevents accidental mutation close to the code that would perform it.