Scope of variables - Step-by-Step Execution

Concept Flow - Scope of variables

Start Program

↓

Declare Global Variable

↓

Enter Function

↓

Declare Local Variable

↓

Use Variables

↓

Exit Function

↓

End Program

This flow shows how variables declared globally and locally are accessed and used inside and outside functions.

Execution Sample

C

#include <stdio.h>
int x = 10; // global

void func() {
  int x = 5; // local
  printf("%d\n", x);
}

int main() {
  func();
  printf("%d\n", x);
  return 0;
}

This code shows a global variable x and a local variable x inside func(), printing both to show scope differences.

Execution Table

Step	Action	Variable x Value	Output
1	Program starts, global x declared	10 (global)
2	Enter func(), local x declared	5 (local shadows global)
3	Print x inside func()	5 (local)	5
4	Exit func(), local x destroyed	10 (global remains)
5	Print x inside main()	10 (global)	10
6	Program ends	10 (global)

💡 Program ends after printing local and global x values showing scope difference.

Variable Tracker

Variable	Start	Inside func() start	Inside func() print	After func() end	main() print	End
x	10 (global)	5 (local shadows global)	5 (local)	10 (global)	10 (global)	10 (global)

Key Moments - 3 Insights

Why does the local variable x inside func() not change the global x?

Because the local x declared inside func() creates a new variable that only exists during func() execution, shadowing the global x. See execution_table steps 2 and 4.

What value of x is printed inside func() and why?

The value 5 is printed because inside func(), the local x (value 5) shadows the global x (value 10). See execution_table step 3.

Why does main() print the global x value 10 after func() ends?

Because the local x inside func() is destroyed after func() ends, so main() accesses the global x which remains 10. See execution_table steps 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of x printed inside func() at step 3?

A 5

B 10

C Undefined

D 0

💡 Hint

Check the 'Output' column at step 3 in the execution_table.

At which step does the local variable x get destroyed?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column describing variable scope changes in execution_table.

If the local variable x inside func() was not declared, what would func() print?

A 5

B 0

C 10

D Compilation error

💡 Hint

Refer to variable_tracker and understand which x is accessed if local x is missing.

Concept Snapshot

Scope of variables in C:
- Global variables declared outside functions are accessible everywhere.
- Local variables declared inside functions exist only during that function's execution.
- Local variables can shadow global variables with the same name.
- After function ends, local variables are destroyed.
- Accessing a variable uses the closest scope first.

Full Transcript

This visual trace shows how variable scope works in C. A global variable x is declared with value 10. Inside the function func(), a local variable x with value 5 is declared, which shadows the global x. When func() prints x, it shows 5. After func() ends, the local x is destroyed, and main() prints the global x value 10. This demonstrates that local variables exist only inside their function and do not affect global variables with the same name.

Practice

1. What is the scope of a variable declared inside a function in C?

easy

A. It can be accessed only in the main function.

B. It is global and can be accessed anywhere in the program.

C. It is local to that function and cannot be accessed outside.

D. It is accessible only in loops inside the function.

Solution

1. Step 1: Understand variable declaration inside a function

   A variable declared inside a function is created when the function starts and destroyed when it ends.

2. Step 2: Identify the scope of such variables

   These variables are local to the function and cannot be accessed outside it.

3. Final Answer:

   It is local to that function and cannot be accessed outside. -> Option C

4. Quick Check:

   Local variable scope = inside function only [OK]

Hint: Local variables stay inside their function only [OK]

Common Mistakes:

• Thinking local variables are global
• Assuming local variables exist outside function
• Confusing local with static variables

2. Which of the following is the correct way to declare a global variable in C?

easy

A. int x; // declared outside any function

B. int x; inside main()

C. static int x; inside a function

D. int x; inside a loop

Solution

1. Step 1: Identify global variable declaration

   Global variables are declared outside all functions, usually at the top of the file.

2. Step 2: Check each option

   int x; // declared outside any function declares int x; outside any function, which is correct for global scope.

3. Final Answer:

   int x; // declared outside any function -> Option A

4. Quick Check:

   Global variables declared outside functions [OK]

Hint: Globals declared outside all functions [OK]

Common Mistakes:

• Declaring globals inside functions
• Using static inside functions for globals
• Declaring variables inside loops thinking they are global

3. What will be the output of the following C code?

int x = 5;
void func() {
    int x = 10;
    printf("%d", x);
}
int main() {
    func();
    printf(" %d", x);
    return 0;
}

medium

A. 10 10

B. 5 10

C. 5 5

D. 10 5

Solution

1. Step 1: Analyze variable scopes in func()

   Inside func(), a local variable x is declared with value 10, which hides the global x.

2. Step 2: Check printf outputs

   First printf prints local x (10). Then main prints global x (5).

3. Final Answer:

   10 5 -> Option D

4. Quick Check:

   Local hides global inside function [OK]

Hint: Local variable hides global inside function [OK]

Common Mistakes:

• Assuming global x prints inside func()
• Mixing order of printed values
• Ignoring local variable shadowing

4. Identify the error in the following C code snippet:

void func() {
    printf("%d", x);
}
int main() {
    int x = 5;
    func();
    return 0;
}

medium

A. x is not declared globally, so func() cannot access it

B. Variable x is used before declaration in func()

C. Missing return type for main()

D. Syntax error in printf statement

Solution

1. Step 1: Check variable x usage in func()

   func() tries to print x but x is declared only inside main(), so func() cannot see it.

2. Step 2: Understand variable scope rules

   Variables declared inside main() are local to main() only, not visible in other functions.

3. Final Answer:

   x is not declared globally, so func() cannot access it -> Option A

4. Quick Check:

   Local variables not visible outside their function [OK]

Hint: Functions can't access locals from other functions [OK]

Common Mistakes:

• Thinking main()'s x is global
• Ignoring variable scope rules
• Assuming implicit global variables

5. Consider the following C code:

int x = 1;
void outer() {
    int x = 2;
    {
        int x = 3;
        printf("%d ", x);
    }
    printf("%d ", x);
}
int main() {
    outer();
    printf("%d", x);
    return 0;
}

What is the output when this program runs?

hard

A. 1 2 3

B. 3 2 1

C. 3 3 3

D. 2 3 1

Solution

1. Step 1: Analyze innermost block variable

   The innermost block declares x = 3, so first printf prints 3.

2. Step 2: Analyze outer block variable

   After inner block ends, the x = 3 goes out of scope, so next printf prints outer x = 2.

3. Step 3: Analyze global variable in main()

   Finally, main prints global x = 1.

4. Final Answer:

   3 2 1 -> Option B

5. Quick Check:

   Inner blocks hide outer variables [OK]

Hint: Inner block variables override outer ones [OK]

Common Mistakes:

• Ignoring block-level scope
• Assuming all x print same value
• Confusing order of prints