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.