Scope of variables

Introduction

Scope tells us where a variable can be used in a program. It helps keep things organized and avoids confusion.

When you want to use a variable only inside a small part of your program, like inside a function.

When you want to share a variable across many parts of your program.

When you want to avoid accidentally changing a variable from another part of the program.

When you want to understand why a variable is not working as expected because it might be out of scope.

Syntax

C

/* Global variable outside functions */
int y = 10; // y is global

/* Local variable inside a function */
int main() {
    int x = 5; // x is local to main
}

void func() {
    // can use y here
}

Local variables exist only inside the block or function where they are declared.

Global variables exist throughout the whole program and can be used anywhere after they are declared.

Examples

Variable b is only available inside the inner block.

C

int main() {
    int a = 3; // a is local to main
    {
        int b = 4; // b is local to this block
    }
    // b cannot be used here
}

Function increment can use the global variable count.

C

int count = 0; // global variable

void increment() {
    count = count + 1; // can access global count
}

Variable x is local to func and not visible in main.

C

void func() {
    int x = 10; // local to func
}

int main() {
    // x cannot be used here
}

Sample Program

This program shows how local_var is only available inside show(), but global_var can be used anywhere.

C

#include <stdio.h>

int global_var = 100; // global variable

void show() {
    int local_var = 50; // local variable
    printf("Inside show(): local_var = %d\n", local_var);
    printf("Inside show(): global_var = %d\n", global_var);
}

int main() {
    show();
    // printf("In main(): local_var = %d\n", local_var); // This would cause error
    printf("In main(): global_var = %d\n", global_var);
    return 0;
}

Important Notes

Trying to use a local variable outside its scope will cause a compile error.

Global variables can make programs harder to understand if overused, so use them carefully.

Blocks inside functions (like inside braces {}) can have their own local variables too.

Summary

Scope defines where a variable can be accessed in a program.

Local variables live inside functions or blocks and cannot be used outside.

Global variables live throughout the program and can be used anywhere after declaration.

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