Reference lifetime in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a reference lifetime in C++?

The reference lifetime is the period during which a reference variable refers to a valid object. It must not outlive the object it references to avoid undefined behavior.

beginner

Why is it dangerous for a reference to outlive the object it refers to?

If a reference outlives its object, it becomes a dangling reference. Accessing it leads to undefined behavior, such as crashes or corrupted data.

intermediate

How does returning a reference to a local variable affect reference lifetime?

Returning a reference to a local variable is unsafe because the local variable is destroyed when the function ends, leaving the reference dangling.

intermediate

What is a common safe practice to extend the lifetime of a temporary object when using references?

Binding a const reference to a temporary object extends the temporary's lifetime to match the reference's lifetime, making it safe to use.

advanced

Explain the difference between lvalue and rvalue references in terms of lifetime.

Lvalue references refer to objects with a stable address and longer lifetime. Rvalue references usually bind to temporary objects with short lifetimes, so care is needed to avoid dangling references.

What happens if a reference in C++ outlives the object it refers to?

A Nothing, the reference remains valid.

B The reference automatically updates to a new object.

C The program throws a compile-time error.

D It becomes a dangling reference causing undefined behavior.

A reference that outlives its object points to invalid memory, causing undefined behavior.

Which of the following safely extends the lifetime of a temporary object?

A Binding it to a const reference.

B Returning a reference to a local variable.

C Using a non-const reference to a temporary.

D Assigning it to a pointer.

Binding a temporary to a const reference extends its lifetime to match the reference.

Why is returning a reference to a local variable unsafe?

A Because local variables have static lifetime.

B Because references cannot be returned from functions.

C Because the local variable is destroyed after the function ends.

D Because references copy the object.

Local variables are destroyed when the function returns, so references to them become invalid.

Which type of reference usually binds to temporary objects?

A Rvalue references.

B Lvalue references.

C Const lvalue references.

D Pointer references.

Rvalue references are designed to bind to temporary (rvalue) objects.

What is a dangling reference?

A A reference that is null.

B A reference that points to an object that no longer exists.

C A reference that points to a valid object.

D A reference that points to a global variable.

A dangling reference points to memory that has been freed or is no longer valid.

Describe what happens to a reference's validity when the object it refers to is destroyed.

Think about what happens if you keep a pointer to a deleted object.

Explain how binding a const reference to a temporary object affects the temporary's lifetime.

Consider how const references can keep temporary objects alive longer.

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