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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a reference to an integer variable.

C++

int x = 10;
int& [1] = x;

Drag options to blanks, or click blank then click option'

Ar

Bptr

Cref

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Using a pointer syntax instead of a reference.

Forgetting the ampersand (&) in the declaration.

The code declares r as a reference to the integer variable x.

2fill in blank

medium

Complete the code to modify the original variable through its reference.

C++

int a = 5;
int& ref = a;
ref [1] 10;
// Now a should be 10

Drag options to blanks, or click blank then click option'

A=

B+=

C-=

D*=

Attempts:

3 left

💡 Hint

Common Mistakes

Using an arithmetic operator instead of assignment.

Not understanding that the reference acts like the original variable.

Assigning 10 to ref changes the original variable a to 10.

3fill in blank

hard

Fix the error in the function parameter to accept a reference.

C++

void increment([1] num) {
    num++;
}

int main() {
    int x = 3;
    increment(x);
    // x should become 4
}

Drag options to blanks, or click blank then click option'

Aint

Bconst int&

Cint*

Dint&

Attempts:

3 left

💡 Hint

Common Mistakes

Passing by value, which does not modify the original variable.

Using a pointer without dereferencing inside the function.

Using int& allows the function to modify the original variable x.

4fill in blank

hard

Fill both blanks to create a function that swaps two integers using references.

C++

void swap([1]& x, [2]& y) {
    int temp = x;
    x = y;
    y = temp;
}

Drag options to blanks, or click blank then click option'

Avoid

Bint

Cconst

Dauto

Attempts:

3 left

💡 Hint

Common Mistakes

Using void& or const int& which prevents modification.

Using pointers instead of references.

The function parameters must be references to int to swap the original values.

5fill in blank

hard

Fill all three blanks to create a function that returns a reference to the larger of two integers.

C++

int& max([1]& a, [2]& b) {
    return (a [3] b) ? a : b;
}

Drag options to blanks, or click blank then click option'

Aconst

Bint

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using const int& which prevents returning a modifiable reference.

Using the wrong comparison operator.

The function returns a reference to the larger integer by comparing a and b.

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