Reference lifetime in C++ - Step-by-Step Execution

Concept Flow - Reference lifetime

Create object

↓

Create reference to object

↓

Use reference

↓

Object lifetime ends

↓

Reference becomes invalid

This flow shows how a reference is tied to the lifetime of the object it refers to. When the object is destroyed, the reference becomes invalid.

Execution Sample

C++

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

int main() {
  int& r = getRef();
  return r;
}

This code returns a reference to a local variable which is destroyed after the function ends, causing a dangling reference.

Execution Table

Step	Action	Variable/Reference State	Notes
1	Enter getRef()	x = uninitialized	Local variable x created
2	Initialize x	x = 10	x assigned 10
3	Return reference to x	r -> x (10)	Reference r in main points to x
4	Exit getRef()	x destroyed	x goes out of scope, memory invalid
5	Use r in main	r -> invalid memory	Reference r is dangling
6	Return r	Undefined behavior	Using dangling reference causes error

💡 Function ends, local variable x destroyed, reference r becomes invalid

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5
x	uninitialized	10	destroyed	destroyed
r	none	points to x (10)	points to invalid	points to invalid

Key Moments - 2 Insights

Why is the reference 'r' invalid after getRef() returns?

Because 'x' is a local variable inside getRef(), it is destroyed when the function ends (see step 4 in execution_table). The reference 'r' then points to memory that no longer holds 'x', making it invalid.

Can a reference extend the lifetime of the object it refers to?

No, a reference does not extend the lifetime of the object. The object must exist independently. In this example, 'x' is destroyed at function end, so the reference 'r' becomes dangling.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'r' after step 4?

A Points to valid object with value 10

B Points to invalid memory (dangling reference)

C Is uninitialized

D Is null

💡 Hint

Check the 'Variable/Reference State' column for step 4 in execution_table

At which step does the local variable 'x' get destroyed?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for when 'x destroyed' appears in the Notes column of execution_table

If 'x' was declared static inside getRef(), how would the execution_table change?

A Reference 'r' would still be invalid after step 4

B 'x' would be destroyed earlier

C 'x' would not be destroyed at step 4, so 'r' remains valid

D Reference 'r' would become null

💡 Hint

Consider object lifetime and when destruction happens in execution_table

Concept Snapshot

Reference lifetime in C++:
- A reference must refer to a valid object.
- References do NOT extend object lifetime.
- Returning reference to local variable causes dangling reference.
- Use only references to objects alive beyond reference use.
- Dangling references cause undefined behavior.

Full Transcript

This example shows how a reference in C++ is tied to the lifetime of the object it refers to. The function getRef() creates a local variable 'x' and returns a reference to it. When the function ends, 'x' is destroyed, but the reference 'r' in main still points to that memory. This makes 'r' a dangling reference, which is invalid and leads to undefined behavior. The execution table traces each step: creation of 'x', returning reference, destruction of 'x', and use of the invalid reference. Key points are that references do not extend object lifetime and returning references to local variables is unsafe. Understanding this helps avoid bugs related to invalid references.

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