Pointer vs Reference in C++: What’s the Difference?

By the end of this page, you will understand how pointers and references work in C++, how they differ, when each is typically used, and what common mistakes beginners should avoid.

Pointers and references in C++ both let you work with another variable indirectly, but they are not the same thing.

A pointer stores the memory address of another object. Because it stores an address, it can:

• point to different objects over time
• be nullptr
• be dereferenced explicitly with *
• support pointer arithmetic in some cases

A reference is an alternate name for an existing object. It does not behave like a separate address-holding variable in normal C++ usage. A reference:

• must be initialized when declared
• cannot later be changed to refer to a different object
• cannot normally be null
• is used without explicit dereferencing syntax

Why this matters

This distinction matters because C++ uses both features heavily:

• references are commonly used for function parameters, return values, and cleaner syntax
• pointers are used when nullability, reassignment, dynamic memory, optional ownership, or low-level memory access is needed

Core idea

If you want a variable that can store an address and possibly change what it points to, use a pointer.

If you want a second name for an existing object, usually for cleaner function interfaces, use a reference.

Think of a variable as a house.

• A pointer is like a piece of paper containing the house address.

  • You can erase the address and write a new one.
  • You can leave it blank (nullptr).
  • To get into the house, you must follow the address.

• A reference is like a permanent nickname for that house.

  • It must refer to a real house immediately.
  • Once assigned, it stays tied to that same house.
  • You use the nickname as if it were the house itself.

So:

• pointer = changeable address holder
• reference = fixed alias

Basic syntax

int value = 10;

int* ptr = &value;   // pointer to value
int& ref = value;    // reference to value

• ptr stores the address of value
• ref becomes another name for value

Using a pointer

#include <iostream>
using namespace std;

int main() {
    int x = 5;
    int* p = &x;

    cout << x << "\n";   // 5
    cout << *p << "\n";  // 5

    *p = 20;
    cout << x << "\n";   // 20
}

Explanation

• p stores the address of x

Consider this example:

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 30;

    int* p = &a;
    int& r = a;

    *p = 15;
    r = 20;
    p = &b;
    *p = 40;

    cout << a << " " << b << "\n";
}

Step-by-step trace

1. int a = 10;

   • a stores 10

2. int b = 30;

   • b stores 30

3. int* p = &a;

   • p stores the address of

When references are commonly used

Function parameters

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

This allows a function to modify the original variable without pointer syntax.

Passing large objects efficiently

void printName(const string& name) {
    cout << name << "\n";
}

Using const string& avoids copying the string while preventing modification.

Operator overloading

References are widely used in C++ operator overloads and class APIs.

When pointers are commonly used

Optional value or object

int* ptr = nullptr;

A pointer can express “no object” clearly.

Dynamic memory and resource management

Raw pointers are less common for ownership in modern C++, but pointers still appear in low-level code and legacy code.

Working with arrays or buffers

Pointers are useful when dealing with contiguous memory, C APIs, or manual memory traversal.

In real C++ projects, developers often choose between pointers and references based on intent.

Common reference patterns

1. Read-only parameter

void logMessage(const std::string& message);

Use this when:

• the argument should not be copied
• the function should not modify it

2. Mutable parameter

void normalizeScore(int& score);

Use this when the function must update the caller’s variable.

3. Return by reference

std::string& getName();

This is used when returning an existing object, not a copy. It must be done carefully to avoid dangling references.

Common pointer patterns

1. Optional parameter

void process(User* user);

A null pointer can mean “no user provided”.

1. Thinking a reference can be reassigned

Broken expectation:

int a = 10;
int b = 20;
int& r = a;

r = b;

Many beginners think r now refers to b. It does not.

What really happens:

• b's value is copied into a
• r still refers to a

2. Dereferencing a null pointer

Broken code:

int* p = nullptr;
cout << *p; // unsafe

This causes undefined behavior.

Avoid it by checking first:

if (p != nullptr) {
    cout << *p;
}

3. Forgetting to initialize a reference

Broken code:

& r; 

Pointer vs reference

int x = 10;
int* p = &x;   // pointer
int& r = x;    // reference

• p stores the address of x
• r is another name for x

Pointer rules

• can be uninitialized temporarily, though that is dangerous
• can be nullptr
• can be reassigned
• access pointed value with *p
• get address with &x

Reference rules

• must be initialized immediately
• cannot be reseated
• usually cannot be null
• used like the original variable

Quick examples

int a = 1;
int b = 2;

int* p = &a;
p = &b; // valid

int& r = a;
r = b;  // copies b into a, does not rebind r

Best practice hints

Is a reference just a pointer with nicer syntax?

Not exactly. They are related ideas, but C++ gives them different rules. A pointer is an address variable; a reference is an alias.

Can a reference be null in C++?

In normal, correct C++ code, a reference should always refer to a valid object. If you need “no object,” use a pointer.

Which is faster: pointer or reference?

Usually there is no meaningful performance difference in typical code. The choice is mainly about semantics, safety, and API design.

Why are references often used in function parameters?

They make code easier to read and avoid copying objects, especially with const T&.

Can I change what a reference refers to later?

No. Once a reference is bound to an object, it stays bound to that object.

When should I use a pointer instead of a reference?

Use a pointer when the value may be absent (nullptr), when you need reseating, or when working with low-level memory or certain APIs.

Are raw pointers still used in modern C++?

Yes, but usually not for ownership. Modern C++ often uses smart pointers for owning relationships and raw pointers for non-owning or low-level access.

• Pass by value — helps compare copying with indirect access.
• Pass by reference — directly related to using references in function parameters.
• Const references — important for efficient read-only access.
• Dereferencing — required to use the value behind a pointer.
• Memory addresses — foundational for understanding pointers.
• Null pointer (nullptr) — central to pointer behavior.
• Dynamic memory allocation — a classic use case for pointers.
• Smart pointers — safer modern alternatives for pointer ownership.
• Dangling references and dangling pointers — important lifetime-related errors.
• Object lifetime — critical for safely using both pointers and references.