References

Introduction

In the previous lesson, you learned about strings. Now consider a situation where you already have a variable and want another name to access the same variable.

int number = 100;

Normally, creating another variable and assigning number to it creates a separate variable containing a copy of the value.

int number = 100;
int anotherNumber = number;

Here, number and anotherNumber are independent variables. Changing one does not automatically change the other.

Sometimes, however, you do not want another copy. You want another name that refers to the original variable itself.

What is a Reference?

A reference is an alias, or another name, for an existing variable.

A reference does not represent an independent value. Instead, operations performed through the reference affect the original object to which it is bound.

int number = 100;
int &ref = number;

In this example, number is the original variable and ref is a reference bound to number.

number ─────┐
             ├────► Same int object
ref ─────────┘

Why Do We Need References?

References become especially useful when programs work with functions, objects, containers, and large amounts of data.

Real-World Analogy

Imagine one person whose official name is Rahul Sharma. Different people may call the same person Rahul, Raju, or Buddy.

Rahul ───────┐
Raju ─────────┼────► Same Person
Buddy ────────┘

The names are different, but they all refer to the same person. A reference works similarly by providing another name for an existing variable.

Characteristics of References

Reference Declaration

To declare an lvalue reference, place the & symbol between the data type and the reference name.

data_type &reference_name = variable_name;

int number = 100;
int &ref = number;

After the declaration, ref can be used to access the same int object as number.

std::cout << number;
std::cout << ref;

Memory Representation

Consider a variable and a reference bound to it.

int number = 100;
int &ref = number;

Names
────────────────────

number ──────┐
             │
ref ─────────┘
             │
             ▼
        ┌─────────┐
        │   100   │
        └─────────┘
          int object

Both names provide access to the same int object. Therefore, changing the value through either name changes the value observed through the other.

std::cout << &number << std::endl;
std::cout << &ref;

Taking the address of number and the address of the object accessed through ref produces the same address.

Example 1: Creating a Reference

#include <iostream>

int main()
{
    int number = 100;
    int &ref = number;

    std::cout << number << std::endl;
    std::cout << ref;

    return 0;
}

100
100

Example 2: Modifying Through a Reference

#include <iostream>

int main()
{
    int number = 50;
    int &ref = number;

    ref = 80;

    std::cout << number << std::endl;
    std::cout << ref;

    return 0;
}

number ─────┐
             ├────► 50
ref ─────────┘

number ─────┐
             ├────► 80
ref ─────────┘

80
80

Important Rules for References

References follow several important rules that beginners must understand.

// ❌ Incorrect
int &ref;

// ✅ Correct
int value = 10;
int &ref = value;

int a = 10;
int b = 20;

int &ref = a;

ref = b;

The statement ref = b; does not make ref refer to b. It assigns the value of b to the object already referenced by ref.

Before:
a = 10
b = 20
ref refers to a

After ref = b:
a = 20
b = 20
ref still refers to a

Program Execution Flow

A reference must be connected to an existing object during initialization. After that, the original variable name and the reference can both be used to access that object.

References vs Variables & Pointers

References are easier to understand when compared with ordinary variables and pointers.

References vs Variables

References vs Pointers

int value = 10;
int &ref = value;

ref = 20;

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

*ptr = 20;

Real-World Applications

void updateScore(int &score)
{
    score = score + 10;
}

int score = 50;

updateScore(score);

std::cout << score;

60

Advantages of References

Common Beginner Mistakes

// ❌ Incorrect
int &ref;

// ✅ Correct
int value = 10;
int &ref = value;

int number = 10;
int &ref = number;

ref = 50;

std::cout << number;

50

int a = 10;
int b = 20;

int &ref = a;

ref = b;

// a is now 20.
// ref still refers to a.

Best Practices

void increase(int &value)
{
    value++;
}

void displayName(const std::string &name)
{
    std::cout << name;
}

Frequently Asked Questions

Key Takeaways

Summary

References are an important feature of C++ that allow another name to access an existing object.

A reference must be initialized when it is declared and cannot later be reseated to another object. When a non-const reference is used to modify a value, the original referenced object is modified.

References are especially useful in function parameters, object-oriented programming, standard library code, and applications that work with large objects. They can help avoid unnecessary copies while providing clean and convenient syntax.

Understanding references also prepares you for pointers. References provide aliasing semantics, while pointers explicitly store memory addresses and provide additional capabilities such as null states and reseating.