Reference vs pointer in C++ - When to Use Which

The Big Idea

Discover how references and pointers save you from confusing and buggy code when sharing data!

The Scenario

Imagine you have a box with a toy inside. You want to tell your friend exactly which toy to play with. You could either give them the toy directly or give them a note with the toy's location. Doing this by hand for many toys can get confusing fast.

The Problem

Manually keeping track of toy locations or passing toys around can be slow and error-prone. You might lose the note or accidentally give the wrong toy. It's hard to update or share toys without making mistakes.

The Solution

References and pointers in C++ act like clear, reliable ways to share or change toys without copying them. References are like giving your friend the toy directly, while pointers are like giving a note with the toy's address. Both help manage toys easily and safely.

Before vs After

✗ Before

int x = 10;
int y = x; // copies value, changes to y don't affect x

✓ After

int x = 10;
int& ref = x; // ref is another name for x
int* ptr = &x; // ptr holds address of x

What It Enables

It enables efficient and clear ways to access and modify data without unnecessary copying or confusion.

Real Life Example

When building a game, you might want multiple characters to share the same weapon. Using references or pointers lets all characters use and update the same weapon without making separate copies.

Key Takeaways

References act like nicknames for variables, always referring to the original.

Pointers hold addresses and can be changed to point elsewhere.

Both help manage data efficiently and avoid mistakes from copying.

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