Reference lifetime in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code involving reference lifetime?

Consider the following C++ code. What will it print when run?

C++

#include <iostream>

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

int main() {
    int& ref = getReference();
    std::cout << ref << std::endl;
    return 0;
}

A Undefined behavior (dangling reference)

B 10

C 0

D Compilation error

💡 Hint

Think about the lifetime of the local variable inside the function.

The function returns a reference to a local variable which is destroyed when the function ends. Using that reference leads to undefined behavior.

❓ Predict Output

intermediate

What is the output of this code with a reference to a static variable?

What will this C++ program print?

C++

#include <iostream>

int& getStaticReference() {
    static int x = 42;
    return x;
}

int main() {
    int& ref = getStaticReference();
    ref = 100;
    std::cout << getStaticReference() << std::endl;
    return 0;
}

A 42

B Undefined behavior

C 100

D Compilation error

💡 Hint

Static variables live for the entire program duration.

The static variable 'x' persists after the function returns. Changing 'ref' changes 'x', so printing it shows 100.

🔧 Debug

advanced

Which option causes a dangling reference error?

Given these code snippets, which one will cause a dangling reference when compiled and run?

A int& foo(int& a) { return a; }

B int& foo() { int a = 5; return a; }

C int& foo() { static int a = 5; return a; }

D int& foo() { static int a = 5; a += 1; return a; }

💡 Hint

Look for references to local variables that do not persist.

Option B returns a reference to a local variable that is destroyed after the function returns, causing a dangling reference.

🧠 Conceptual

advanced

What is the lifetime of a reference to a temporary object?

In C++, what happens to the lifetime of a temporary object when it is bound to a const reference?

A The temporary object's lifetime is extended to match the lifetime of the const reference.

B The temporary object is copied and the reference points to the copy.

C The temporary object lives forever.

D The temporary object is destroyed immediately after the expression.

💡 Hint

Think about how const references can extend lifetimes.

Binding a temporary to a const reference extends the temporary's lifetime to the lifetime of the reference.

❓ Predict Output

expert

What is the output and why? (Complex reference lifetime)

Analyze this code and select the correct output.

C++

#include <iostream>

int& getRef(bool flag) {
    if (flag) {
        static int x = 1;
        return x;
    } else {
        int y = 2;
        return y;
    }
}

int main() {
    int& r1 = getRef(true);
    int& r2 = getRef(false);
    std::cout << r1 << ' ' << r2 << std::endl;
    return 0;
}

A Undefined behavior Undefined behavior

B Compilation error

C 1 2

D 1 Undefined behavior

💡 Hint

Consider which references are safe and which are dangling.

r1 refers to a static variable and is safe. r2 refers to a local variable that is destroyed after the function returns, causing undefined behavior.