Answer.

The scope of identifiers is the part of the program where a certain object (variable, function, constant) is accessible by its name. In the C language, this mechanism has been implemented to simplify the writing, testing, and maintenance of large multi-module programs.

Background:

The emergence of scopes is related to the need to structure programs and limit the influence of variables on different parts of the code to avoid name conflicts and unpredictable behavior.

Problem:

If only global variables are used, it is easy to fall into "classic" mistakes of duplication or accidental value changes. Variables declared in one scope may be unavailable or conflict with variables in another, leading to errors and complicating debugging.

Solution:

In the C language, there are several levels of scope:

Project (external) — variables/functions are declared outside all functions and accessible from any file via extern.
File (static) — declared outside the function and marked static, accessible only within the current file.
Block (local) — declared within the {} block of the function, accessible only in this block.
Scope of function parameters and for loop variables.

Example code:

static int file_var = 0; // visible only inside the file
int global_var = 1;      // visible in all files

void func() {
    int block_var = 2;   // visible only inside func
    for (int i = 0; i < 3; i++) {
        // i is accessible only inside this for
    }
}

Key features:

Proper scope management makes code maintenance and development easier.
Local variables protect against "polluting" the global namespace.
Using static for variables and functions limits their accessibility to other modules.

Trick Questions.

What happens if a variable is declared in a header file without static?

If a variable is declared and defined in a .h without static, and this header is included in several files, a linking error will occur: Multiple definition. Always use extern in header files or static for privacy.

What happens to a local variable when it goes out of scope?

The local variable "dies": its memory is freed, its value is lost, and any further access is an error.

if (1) {
    int temp = 5;
}
// printf("%d", temp); // ERROR: temp is out of scope

Can a function be declared static, and what does it give?

Yes, declaring a function static makes it visible only in the current file. This is useful for encapsulating helper functions.

Typical Mistakes and Anti-Patterns

Unnecessary global variables (creating fragile dependencies between code parts)
Name duplication and "polluted" namespaces
Using variables outside their scope, accessing already freed memory

Real Life Example

Negative Case

Declaring a variable in a header file without static and including it in several .c files:

// myheader.h
int count = 0; // bad

Pros:

Convenient for quick debugging of small projects

Cons:

Linker errors, unpredictable behavior, debugging difficulties

Positive Case

Using extern and static to manage scope:

// myheader.h
extern int count; // good

// myfile.c
static void helper() { }
int count = 0;