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.

Practice

1. What does reference lifetime in C++ mean?

easy

A. The time it takes to create a reference

B. How long a reference remains valid during program execution

C. The size of the reference in memory

D. The number of references to a variable

Solution

1. Step 1: Understand what a reference is

   A reference is an alias for another variable, so it must point to valid data.

2. Step 2: Define lifetime in this context

   Reference lifetime means the duration the reference points to valid memory without becoming invalid.

3. Final Answer:

   How long a reference remains valid during program execution -> Option B

4. Quick Check:

   Reference lifetime = validity duration [OK]

Hint: Reference lifetime = how long it stays valid [OK]

Common Mistakes:

• Confusing lifetime with creation time
• Thinking lifetime is about memory size
• Assuming references count how many times used

2. Which of the following is the correct way to declare a reference to an int variable x?

easy

A. int &ref = x;

B. int ref = &x;

C. int &ref();

D. int *ref = x;

Solution

1. Step 1: Recall reference declaration syntax

   References use & after the type, e.g., int &ref.

2. Step 2: Check each option

   int &ref = x; correctly declares a reference to x. Others either declare pointers or incorrect syntax.

3. Final Answer:

   int &ref = x; -> Option A

4. Quick Check:

   Reference syntax = type &name = variable [OK]

Hint: References use & after type, not * or parentheses [OK]

Common Mistakes:

• Using * instead of & for references
• Adding parentheses after reference name
• Assigning address instead of reference

3. What will be the output of this code?

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

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

medium

A. Undefined behavior (likely garbage value)

B. Compilation error

C. 10

D. 0

Solution

1. Step 1: Analyze function return

   The function returns a reference to a local variable x which is destroyed after the function ends.

2. Step 2: Understand consequences

   Using that reference in main leads to undefined behavior because x no longer exists.

3. Final Answer:

   Undefined behavior (likely garbage value) -> Option A

4. Quick Check:

   Returning local reference = undefined behavior [OK]

Hint: Never return references to local variables [OK]

Common Mistakes:

• Assuming local variable reference is valid after return
• Expecting compilation error
• Thinking it prints 0 always

4. Identify the error in this code snippet:

int& createRef() {
    int temp = 5;
    return temp;
}

int main() {
    int &r = createRef();
    std::cout << r << std::endl;
}

medium

A. Reference variable declared without initialization

B. Missing semicolon after return statement

C. Returning reference to a local variable which is destroyed

D. Using & instead of * for pointer

Solution

1. Step 1: Check what is returned

   The function returns a reference to temp, a local variable.

2. Step 2: Understand lifetime issue

   Local variable temp is destroyed when function ends, so reference is invalid.

3. Final Answer:

   Returning reference to a local variable which is destroyed -> Option C

4. Quick Check:

   Returning local reference = lifetime error [OK]

Hint: Local variables die after function ends; don't return their references [OK]

Common Mistakes:

• Thinking compiler allows returning local references safely
• Confusing references with pointers
• Ignoring variable lifetime rules

5. How can you safely return a reference from a function in C++?

hard

A. Return a reference to a temporary object

B. Return a reference to a local variable

C. Return a pointer instead of a reference

D. Return a reference to a static or global variable

Solution

1. Step 1: Understand safe reference return

   References must refer to valid memory after function ends.

2. Step 2: Identify valid memory sources

   Static or global variables live beyond function scope, so returning their reference is safe.

3. Step 3: Evaluate other options

   Local variables and temporaries die after function ends; pointers don't guarantee safety here.

4. Final Answer:

   Return a reference to a static or global variable -> Option D

5. Quick Check:

   Safe reference return = static/global variable [OK]

Hint: Return references only to static/global variables [OK]

Common Mistakes:

• Returning references to local variables
• Confusing pointers with references
• Returning references to temporary objects