Reference vs pointer in C++

Introduction

References and pointers both let you work with other variables indirectly. They help you change or use data without copying it.

When you want to pass a variable to a function without copying it.

When you want to change the original variable inside a function.

When you want to refer to an object with a simpler name.

When you need to manage memory manually using pointers.

When you want to create dynamic data structures like linked lists.

Syntax

C++

int x = 10;
int &ref = x;  // reference
int *ptr = &x;  // pointer

A reference is like a nickname for a variable. It must be set when created and cannot be changed to refer to something else.

A pointer holds the address of a variable. It can be changed to point to different variables or be null.

Examples

Reference acts like another name for a. Changing r changes a.

C++

int a = 5;
int &r = a;  // r is a reference to a
r = 10;  // changes a to 10

Pointer p stores address of b. Using *p accesses the value at that address.

C++

int b = 7;
int *p = &b;  // p points to b
*p = 20;  // changes b to 20

Pointers can be changed to point to different variables.

C++

int c = 3;
int d = 4;
int *ptr = &c;
ptr = &d;  // pointer can point to d now

References cannot be reseated to another variable after initialization.

C++

int e = 8;
int &ref = e;
// ref cannot be changed to refer to another variable

Sample Program

This program shows how references and pointers both access and change the original variable. It also shows that pointers can point to different variables, but references cannot.

C++

#include <iostream>

int main() {
    int x = 10;
    int &ref = x;       // reference to x
    int *ptr = &x;      // pointer to x

    std::cout << "x = " << x << "\n";
    std::cout << "ref = " << ref << "\n";
    std::cout << "*ptr = " << *ptr << "\n";

    ref = 20;           // changes x
    std::cout << "After ref = 20; x = " << x << "\n";

    *ptr = 30;          // changes x
    std::cout << "After *ptr = 30; x = " << x << "\n";

    int y = 40;
    ptr = &y;           // pointer now points to y
    std::cout << "After ptr = &y; *ptr = " << *ptr << "\n";

    // ref = y; // This would change x to 40, not ref to y

    return 0;
}

Important Notes

References must be initialized when declared and cannot be null.

Pointers can be null and can be reassigned to point to different variables.

Use references when you want simpler syntax and guaranteed valid objects.

Summary

References are aliases for variables and cannot be changed to refer to something else.

Pointers hold addresses and can be reassigned or set to null.

Both let you work with variables indirectly to save memory and allow changes.

Practice

1. Which of the following statements correctly describes a reference in C++?

easy

A. A reference is an alias for another variable and cannot be changed to refer to another variable.

B. A reference holds the memory address of a variable and can be reassigned.

C. A reference can be null and does not need to be initialized.

D. A reference is a pointer that requires explicit dereferencing.

Solution

1. Step 1: Understand what a reference is

   A reference acts as another name for an existing variable and must be initialized when declared.

2. Step 2: Compare with pointers

   Unlike pointers, references cannot be changed to refer to another variable or be null.

3. Final Answer:

   A reference is an alias for another variable and cannot be changed to refer to another variable. -> Option A

4. Quick Check:

   Reference = alias, fixed binding [OK]

Hint: References alias variables and never change target [OK]

Common Mistakes:

• Thinking references can be null
• Confusing references with pointers
• Assuming references can be reassigned

2. Which of the following is the correct syntax to declare a pointer to an integer in C++?

easy

A. int ptr;

B. int *ptr;

C. int &ptr;

D. int ptr*&;

Solution

1. Step 1: Recall pointer declaration syntax

   In C++, a pointer to an int is declared using an asterisk (*) before the variable name.

2. Step 2: Analyze options

   int *ptr; uses "int *ptr;" which correctly declares a pointer to int. int ptr; declares an int variable, B declares a reference, and D is invalid syntax.

3. Final Answer:

   int *ptr; -> Option B

4. Quick Check:

   Pointer syntax = int *ptr [OK]

Hint: Pointer declaration uses * before variable name [OK]

Common Mistakes:

• Omitting the * for pointer declaration
• Using & which declares a reference
• Combining * and & incorrectly

3. What will be the output of the following C++ code?

int x = 10;
int &ref = x;
int *ptr = &x;
ref = 20;
*ptr = 30;
std::cout << x << std::endl;

medium

A. 30

B. 20

C. 10

D. Compilation error

Solution

1. Step 1: Trace reference assignment

   ref is a reference to x, so ref = 20 sets x to 20.

2. Step 2: Trace pointer assignment

   ptr points to x, so *ptr = 30 sets x to 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Reference and pointer both modify x = 30 [OK]

Hint: Both ref and *ptr change x directly [OK]

Common Mistakes:

• Thinking ref and ptr are independent variables
• Confusing pointer dereference syntax
• Assuming ref can be reassigned

4. Identify the error in the following code snippet:

int a = 5;
int &ref;
ref = a;
std::cout << ref << std::endl;

medium

A. Cannot assign a variable to a reference.

B. Missing * for pointer declaration.

C. Reference must be initialized when declared.

D. Reference cannot be used with std::cout.

Solution

1. Step 1: Check reference declaration rules

   References must be initialized at the time of declaration; they cannot be declared without initialization.

2. Step 2: Analyze the code

   int &ref; is invalid because ref is not initialized. Assigning ref = a; later is not initialization but assignment.

3. Final Answer:

   Reference must be initialized when declared. -> Option C

4. Quick Check:

   Reference declaration requires immediate initialization [OK]

Hint: References need initialization on declaration [OK]

Common Mistakes:

• Thinking references can be declared then assigned
• Confusing assignment with initialization
• Assuming pointers and references behave the same

5. Given the following code, what will be the output?

int x = 5;
int y = 10;
int *ptr = &x;
int &ref = y;
ptr = &y;
ref = *ptr + 5;
std::cout << x << ", " << y << std::endl;

hard

A. Compilation error

B. 5, 10

C. 5, 20

D. 5, 15

Solution

1. Step 1: Trace pointer reassignment

   ptr initially points to x, then is reassigned to point to y.

2. Step 2: Trace reference and assignment

   ref is a reference to y. The statement ref = *ptr + 5 means y = y + 5 (since ptr points to y).

3. Step 3: Final values

   x remains 5, y becomes 10 + 5 = 15.

4. Final Answer:

   5, 15 -> Option D

5. Quick Check:

   Pointer changes target; reference updates y = 15 [OK]

Hint: Pointer can change target; reference fixed to y [OK]

Common Mistakes:

• Assuming reference ref points to x
• Forgetting pointer reassignment
• Confusing reference assignment with pointer assignment