References in C++

A reference in C++ is an alias — another name for an existing variable. Once bound, the reference is that variable: anything you do to the reference happens to the original. References give you the power of pointers for passing and sharing data, but with a cleaner, safer syntax. They are the preferred way to pass objects into functions without copying.

Here is the simplest form.

A reference is an alias

You create a reference with & in the declaration, and you must bind it immediately.

#include <iostream>

int main() {
    int score = 10;
    int& alias = score;   // alias is another name for score

    alias = 25;           // changes score itself
    std::cout << score << "\n";   // 25
}

There is no separate alias variable — score and alias are the same storage. A reference cannot be rebound to a different variable later, and it must be initialised when declared.

Passing by reference

The most common use is letting a function modify its caller's variable, or read a large object without copying it.

#include <iostream>

// takes a reference, so it edits the caller's value
void addBonus(int& points, int bonus) {
    points += bonus;
}

int main() {
    int points = 100;
    addBonus(points, 50);
    std::cout << points << "\n";   // 150 — the original changed
}

Compare this with passing by value, where the function would work on a copy and the caller's points would stay 100.

const references: efficient read-only access

Passing a large object by value copies the whole thing. Passing a const reference avoids the copy and promises not to modify it — the best choice for read-only parameters.

#include <iostream>
#include <string>

// no copy made; the function cannot modify the string
void printName(const std::string& name) {
    std::cout << "Name: " << name << "\n";
    // name = "x";  // ERROR: name is const
}

int main() {
    std::string student = "Asha";
    printName(student);   // efficient: passes a reference, not a copy
}

Rule of thumb: pass cheap types (int, double) by value, and pass larger objects (std::string, std::vector, your own classes) by const& when you only read them.

References vs pointers

Prefer references when you always have a valid object and never need to "point at nothing." Use a pointer (or std::optional) when absence is meaningful.

Beware dangling references

A reference must not outlive what it refers to. Returning a reference to a local variable is a classic bug — the local is destroyed when the function returns.

// BAD: returns a reference to a destroyed local
const std::string& broken() {
    std::string temp = "oops";
    return temp;           // temp dies here -> dangling reference
}

Return by value instead, or return a reference only to something that outlives the call (like a member or a passed-in argument).

Common mistakes

• Forgetting to initialise a reference. int& r; is a compile error — a reference must bind on declaration.
• Returning a reference to a local variable. The local is destroyed on return, leaving a dangling reference and undefined behaviour.
• Passing big objects by value out of habit. Use const& for read-only parameters to skip the copy.
• Expecting to rebind a reference. Assigning to a reference changes the referred-to value, it does not point the reference somewhere new.

FAQ

What is the difference between a reference and a pointer? A reference is a permanent alias that must always refer to a valid object and cannot be null or rebound. A pointer can be null, can be reassigned, and uses explicit */& syntax.

When should I use a const reference parameter? Whenever a function only reads a non-trivial object. It avoids copying while guaranteeing the function will not change the caller's data.

Keep learning

• See references in action with class methods in Classes & Objects in C++.
• They underpin run-time polymorphism — see Polymorphism in C++.
• Browse the full series on the C++ OOP hub.

Get comfortable with C++ memory and references through guided practice — join the waitlist for our C++ Programming course in Jalgaon.