Lifetime and scope comparison - Step-by-Step Execution

Concept Flow - Lifetime and scope comparison

Start Program

↓

Declare Variables

↓

Enter Function

↓

Check Variable Scope

↓

Local

↓

Lifetime & Scope Behavior

↓

End Program

This flow shows how variables are declared and how their lifetime and scope differ depending on whether they are local, global, or static.

Execution Sample

C

#include <stdio.h>
int global_var = 10;

void func() {
    int local_var = 5;
    static int static_var = 0;
    static_var++;
    printf("%d %d %d\n", global_var, local_var, static_var);
}

int main() {
    func();
    func();
    return 0;
}

This code shows global, local, and static variables and how their values change or reset across function calls.

Execution Table

Step	Variable	Value	Scope	Lifetime	Action	Output
1	global_var	10	Global	Whole program	Initialized before main
2	func() call 1				Enter func
3	local_var	5	Local to func	During func call	Initialized
4	static_var	0	Static local	Whole program	Initialized once
5	static_var	1	Static local	Whole program	Incremented
6	Output				Print values	10 5 1
7	func() call 1				Exit func, local_var destroyed
8	func() call 2				Enter func again
9	local_var	5	Local to func	During func call	Initialized again
10	static_var	1	Static local	Whole program	Retains previous value
11	static_var	2	Static local	Whole program	Incremented
12	Output				Print values	10 5 2
13	func() call 2				Exit func, local_var destroyed
14	Program End				main returns, program ends

💡 Program ends after main returns; local variables destroyed after each func call; static and global variables persist.

Variable Tracker

Variable	Start	After func call 1	After func call 2	Final
global_var	10	10	10	10
local_var	N/A	5 (exists during call)	5 (exists during call)	N/A (destroyed after calls)
static_var	0	1	2	2

Key Moments - 3 Insights

Why does static_var keep its value between function calls but local_var does not?

Because static_var has static lifetime and is initialized only once, it keeps its value across calls. local_var is created and destroyed each time func runs, so it resets (see execution_table rows 4-7 and 9-13).

Does global_var change during the program execution?

No, global_var is initialized once before main and remains unchanged throughout (see execution_table rows 1, 6, and 12).

When exactly is local_var created and destroyed?

local_var is created at the start of each func call and destroyed when func returns (see execution_table rows 3 and 7 for first call, 9 and 13 for second).

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the value of static_var?

A 5

B 0

C 1

D 10

💡 Hint

Check the 'Value' column for static_var at step 5 in execution_table.

At which step does local_var get destroyed after the first func call?

A Step 3

B Step 7

C Step 6

D Step 9

💡 Hint

Look for the action mentioning local_var destruction after func call 1 in execution_table.

If static_var was not static, what would be its value at step 11?

A 1

B 2

C 0

D Undefined

💡 Hint

Consider that non-static local variables are reinitialized each call (see variable_tracker for static_var changes).

Concept Snapshot

Lifetime and Scope in C:
- Global variables: scope whole program, lifetime entire run
- Local variables: scope inside function/block, lifetime during call
- Static local variables: scope local, lifetime entire program
- Static variables keep value between calls
- Local variables reset each call

Full Transcript

This example compares lifetime and scope of variables in C. Global variables exist and keep their value throughout the program. Local variables exist only during a function call and are destroyed after. Static local variables behave like locals in scope but keep their value between calls because their lifetime is the whole program. The execution table shows how static_var increments across calls, local_var resets, and global_var stays constant. Key moments clarify why static_var retains value and when local_var is created and destroyed. The quiz tests understanding of these concepts by referencing specific steps and variable values.

Practice

1. Which of the following best describes the scope of a variable in C?

easy

A. The time duration the variable exists in memory

B. The amount of memory the variable uses

C. The part of the program where the variable can be accessed

D. The data type of the variable

Solution

1. Step 1: Understand the meaning of scope

   Scope means where in the code a variable can be used or accessed.

2. Step 2: Differentiate scope from lifetime

   Lifetime is about how long the variable exists in memory, not where it can be used.

3. Final Answer:

   The part of the program where the variable can be accessed -> Option C

4. Quick Check:

   Scope = where variable is accessible [OK]

Hint: Scope means where variable is visible in code [OK]

Common Mistakes:

• Confusing scope with lifetime
• Thinking scope is about memory size
• Mixing scope with data type

2. Which declaration correctly creates a variable with local scope and static lifetime inside a function?

easy

A. static int count = 0;

B. int static count = 0;

C. auto static int count = 0;

D. register static int count = 0;

Solution

1. Step 1: Recall correct syntax for static local variable

   The keyword static comes before the type: static int count = 0;.

2. Step 2: Identify invalid syntax options

   int static count = 0; has incorrect order. auto static int count = 0; and register static int count = 0; use invalid combinations of storage class specifiers.

3. Final Answer:

   static int count = 0; -> Option A

4. Quick Check:

   Static local variable syntax = static before type [OK]

Hint: Put 'static' before type for static local variable [OK]

Common Mistakes:

• Placing 'static' after type
• Combining 'auto' and 'static' incorrectly
• Using 'register' with 'static'

3. What is the output of this C code?

void func() {
    static int x = 0;
    x++;
    printf("%d ", x);
}

int main() {
    for(int i = 0; i < 3; i++) {
        func();
    }
    return 0;
}

medium

A. 1 2 3

B. 1 1 1

C. 0 1 2

D. 3 3 3

Solution

1. Step 1: Understand static variable behavior inside function

   Static variable x keeps its value between function calls and starts at 0.

2. Step 2: Trace the loop and function calls

   Each call increments x by 1 and prints it: first 1, then 2, then 3.

3. Final Answer:

   1 2 3 -> Option A

4. Quick Check:

   Static variable increments across calls = 1 2 3 [OK]

Hint: Static variables keep value between calls [OK]

Common Mistakes:

• Assuming static resets each call
• Confusing initial value of static variable
• Ignoring the loop effect

4. Identify the error in this code snippet related to variable scope:

int main() {
    if (1) {
        int a = 5;
    }
    printf("%d", a);
    return 0;
}

medium

A. Variable 'a' should be declared static

B. Missing semicolon after variable declaration

C. printf format specifier is incorrect

D. Variable 'a' is used outside its scope

Solution

1. Step 1: Check where 'a' is declared and used

   'a' is declared inside the if-block and cannot be accessed outside it.

2. Step 2: Understand scope rules

   Variables declared inside braces have local scope limited to those braces, so 'a' is out of scope in printf.

3. Final Answer:

   Variable 'a' is used outside its scope -> Option D

4. Quick Check:

   Using variable outside its block scope causes error [OK]

Hint: Variables only visible inside their braces [OK]

Common Mistakes:

• Trying to use variable outside its block
• Thinking static fixes scope errors
• Ignoring variable lifetime vs scope

5. Consider this code:

void counter() {
    static int count = 0;
    int temp = 0;
    count++;
    temp++;
    printf("%d %d\n", count, temp);
}

int main() {
    for (int i = 0; i < 3; i++) {
        counter();
    }
    return 0;
}

What will be the output and why?

hard

A. 1 1
2 2
3 3
Because both variables keep their values between calls

B. 1 1
2 1
3 1
Because 'count' is static and 'temp' is local each call

C. 1 0
1 0
1 0
Because 'temp' is never incremented properly

D. 0 0
0 0
0 0
Because variables are not initialized

Solution

1. Step 1: Analyze 'count' variable behavior

   'count' is static, so it keeps incrementing across calls: 1, 2, 3.

2. Step 2: Analyze 'temp' variable behavior

   'temp' is local and reinitialized to 0 each call, so it increments to 1 every time.

3. Step 3: Understand output pattern

   Output lines are: "1 1", "2 1", "3 1" matching the behavior above.

4. Final Answer:

   1 1 2 1 3 1 Because 'count' is static and 'temp' is local each call -> Option B

5. Quick Check:

   Static keeps value; local resets each call [OK]

Hint: Static persists, local resets each function call [OK]

Common Mistakes:

• Assuming local variable keeps value between calls
• Confusing initialization of static vs local
• Ignoring that temp resets every call