Why references are needed in C++ - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function modifying variable via reference

What is the output of this C++ code that uses a reference to modify a variable?

C++

#include <iostream>

void addFive(int &num) {
    num += 5;
}

int main() {
    int a = 10;
    addFive(a);
    std::cout << a << std::endl;
    return 0;
}

A 15

B 10

C 5

D Compilation error

💡 Hint

Remember that passing by reference allows the function to change the original variable.

The function addFive takes an int reference and adds 5 to it. Since 'a' is passed by reference, its value changes from 10 to 15.

🧠 Conceptual

intermediate

Why use references instead of pointers?

Which of the following is a key reason to use references instead of pointers in C++?

A References can be null, pointers cannot

B References use more memory than pointers

C References require explicit dereferencing like pointers

D References must be initialized and cannot be reseated, pointers can be changed

💡 Hint

Think about how references behave after initialization compared to pointers.

References must be initialized when declared and cannot be changed to refer to another object, unlike pointers which can be reassigned and can be null.

❓ Predict Output

advanced

Output of swapping two variables using references

What is the output of this C++ code that swaps two integers using references?

C++

#include <iostream>

void swap(int &x, int &y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 3, b = 7;
    swap(a, b);
    std::cout << a << " " << b << std::endl;
    return 0;
}

A 3 7

B 0 0

C 7 3

D Compilation error

💡 Hint

The swap function exchanges the values of the two variables passed by reference.

The swap function uses references to directly change the values of 'a' and 'b'. After swapping, 'a' becomes 7 and 'b' becomes 3.

🔧 Debug

advanced

Identify the error in reference usage

What error does this C++ code produce and why?

C++

int& getReference() {
    int x = 10;
    return x;
}

int main() {
    int &ref = getReference();
    return 0;
}

A Compilation error: missing return statement

B Runtime error: dangling reference to local variable

C No error, code runs fine

D Compilation error: cannot bind non-const lvalue reference to a temporary

💡 Hint

Think about the lifetime of the variable 'x' returned by reference.

The function returns a reference to a local variable 'x' which is destroyed when the function ends, causing a dangling reference and undefined behavior at runtime.

🧠 Conceptual

expert

Why references improve function parameter passing

Which statement best explains why references are preferred for passing large objects to functions in C++?

A References avoid copying the object, improving performance and allowing modification

B References create a copy of the object, increasing safety

C References always make the object constant inside the function

D References require explicit dereferencing, making code clearer

💡 Hint

Consider the cost of copying large objects and the ability to modify them.

Passing by reference avoids the overhead of copying large objects and allows the function to modify the original object if needed.

Practice

1. Why do we need references in C++?

easy

A. To allow functions to modify the original variable without copying it

B. To create a new copy of a variable

C. To store multiple values in one variable

D. To make variables constant

Solution

1. Step 1: Understand what references do

   References let you use another name for the same variable, so changes affect the original.

2. Step 2: Compare with copying

   Copying creates a new variable, so changes do not affect the original.

3. Final Answer:

   To allow functions to modify the original variable without copying it -> Option A

4. Quick Check:

   References modify original data = A [OK]

Hint: References let functions change original variables directly [OK]

Common Mistakes:

• Thinking references create copies
• Confusing references with pointers
• Believing references make variables constant

2. Which of the following is the correct syntax to declare a reference to an integer variable num?

easy

A. int *ref = num;

B. int ref = #

C. int &ref = num;

D. int ref & = num;

Solution

1. Step 1: Recall reference declaration syntax

   References use & after the type, like int &ref.

2. Step 2: Check each option

   int &ref = num; matches correct syntax. Others misuse pointers or symbols.

3. Final Answer:

   int &ref = num; -> Option C

4. Quick Check:

   Reference syntax = int &ref = var [OK]

Hint: References use & after type, not before variable name [OK]

Common Mistakes:

• Using * instead of & for references
• Placing & after variable name
• Confusing pointers and references syntax

3. What will be the output of this code?

void addOne(int &x) {
  x = x + 1;
}

int main() {
  int a = 5;
  addOne(a);
  std::cout << a;
  return 0;
}

medium

A. 5

B. 6

C. Compilation error

D. Undefined behavior

Solution

1. Step 1: Understand the function parameter

   The function addOne takes x as a reference, so it modifies the original variable.

2. Step 2: Trace the code execution

   Variable a is 5, addOne(a) adds 1, so a becomes 6. Then it prints 6.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Reference changes original = 6 [OK]

Hint: Reference parameters change original variables inside functions [OK]

Common Mistakes:

• Thinking the value stays 5 after function call
• Confusing references with copies
• Expecting compilation error due to reference

4. Identify the error in this code snippet:

void swap(int &a, int &b) {
  int temp = a;
  a = b;
  b = temp;
}

int main() {
  int x = 10, y = 20;
  swap(x, y);
  std::cout << x << " " << y;
  return 0;
}

medium

A. Function parameters should be pointers, not references

B. Missing & in function parameters

C. Cannot use references in function parameters

D. No error, code swaps values correctly

Solution

1. Step 1: Check function parameter types

   The function uses references correctly to swap values.

2. Step 2: Verify code logic and output

   The swap logic is correct and will print swapped values: 20 10.

3. Final Answer:

   No error, code swaps values correctly -> Option D

4. Quick Check:

   References swap values correctly = D [OK]

Hint: References can be used to swap variables without pointers [OK]

Common Mistakes:

• Thinking pointers are required for swap
• Believing references cannot be function parameters
• Assuming code has syntax errors

5. You want to write a function that doubles the value of an integer passed to it. Which approach best uses references to achieve this efficiently?

hard

A. void doubleValue(int &x) { x = x * 2; }

B. void doubleValue(int x) { x = x * 2; }

C. void doubleValue(int *x) { *x = *x * 2; }

D. int doubleValue(int x) { return x * 2; }

Solution

1. Step 1: Understand the goal

   The function should change the original integer's value directly.

2. Step 2: Evaluate each option

   void doubleValue(int x) { x = x * 2; } changes only a copy, no effect outside. void doubleValue(int &x) { x = x * 2; } uses reference to modify original. void doubleValue(int *x) { *x = *x * 2; } uses pointer, works but less simple. int doubleValue(int x) { return x * 2; } returns new value, caller must assign.

3. Final Answer:

   void doubleValue(int &x) { x = x * 2; } -> Option A

4. Quick Check:

   Use references to modify original efficiently = A [OK]

Hint: Use references to change original variables without pointers [OK]

Common Mistakes:

• Using pass-by-value and expecting original to change
• Confusing pointers with references
• Forgetting to assign returned value when not using references