Scope & Storage Classes

Every variable in C has two properties that beginners often mix up. Its scope is the part of the code where its name can be used. Its lifetime, which the standard calls its storage duration, is how long its memory exists while the program runs.

In this lesson you will learn block scope and file scope, see how static makes a local variable remember its value between calls, and use static and extern to control which variables other files can see.

Block scope

A variable declared inside braces has block scope: it can be used from its declaration to the closing brace of that block. A function's parameters have the scope of the function body.

#include <stdio.h>

int main(void)
{
    int x = 10;
    printf("Outer x: %d\n", x);

    {
        int x = 20;   // a new x that hides the outer one
        int y = 5;
        printf("Inner x: %d, y: %d\n", x, y);
    }

    printf("Outer x again: %d\n", x);
    // printf("%d\n", y);   // error: 'y' undeclared
    return 0;
}

Outer x: 10
Inner x: 20, y: 5
Outer x again: 10

The inner block declares its own x, which shadows (hides) the outer one until the block ends. The outer x is untouched. After the block, y no longer exists, so using it is a compile error. Shadowing is legal but confusing; GCC's -Wshadow option warns about it.

Local variables have automatic storage duration: they are created each time the block is entered and destroyed when it ends. That is why a function's local variables start fresh on every call.

File scope: global variables

A variable declared outside every function has file scope: every function below it in the file can use it. Such variables are often called global variables. They live for the whole run of the program and, unlike local variables, start at zero if you do not initialise them.

#include <stdio.h>

int visitors;   // global: starts at 0 automatically

void gate_entry(void)
{
    visitors++;
}

int main(void)
{
    gate_entry();
    gate_entry();
    gate_entry();
    printf("Visitors today: %d\n", visitors);
    return 0;
}

Visitors today: 3

Globals are convenient but risky. Any function can change them, so when a value is wrong, you must search the whole program to find out who changed it. Prefer passing values as parameters and returning results. Keep globals for things that really belong to the whole program, and give them clear names.

static local variables

Adding static to a local variable changes its lifetime but not its scope. The variable is still visible only inside its function, but it is created once, before the program starts, and keeps its value between calls.

#include <stdio.h>

int next_token(void)
{
    static int token = 100;   // initialised once, remembers its value
    token++;
    return token;
}

int count_calls_wrong(void)
{
    int calls = 0;            // a fresh variable on every call
    calls++;
    return calls;
}

int main(void)
{
    for (int i = 0; i < 3; i++) {
        printf("Token %d, wrong counter %d\n", next_token(), count_calls_wrong());
    }
    return 0;
}

Token 101, wrong counter 1
Token 102, wrong counter 1
Token 103, wrong counter 1

token behaves like a bank's token machine: each call hands out the next number. The line static int token = 100; runs its initialisation only once, not on every call. In count_calls_wrong, calls is automatic, so it is reset to 0 every time and the function always returns 1.

How long variables live

C has four storage durations:

Allocated memory is the subject of Dynamic Memory. Thread storage matters only in programs that run several threads at once; C23 spells the keyword thread_local, while C11 code writes _Thread_local.

A classic bug comes from automatic lifetime: a function must never hand back the address of one of its local variables, because that memory is gone as soon as the function returns. GCC warns "function returns address of local variable". You will see why in Pointers, NULL & nullptr.

static and extern across files

Real programs are split into several .c files. At file level, two keywords decide what other files can see:

• A global variable or function is shared with other files by default. Another file uses it after declaring it with extern, which says "this exists, but it is defined somewhere else".
• Adding static at file level makes a global variable or function private to its own file. Other files cannot see it, even with extern.

Here is a program made of two files:

// counter.c
static int count = 0;       // private to this file
int total_visitors = 0;     // shared with other files

void add_visitor(void)
{
    count++;
    total_visitors++;
}

int visitors_here(void)
{
    return count;
}

// main.c
#include <stdio.h>

extern int total_visitors;  // defined in counter.c
void add_visitor(void);
int visitors_here(void);

int main(void)
{
    add_visitor();
    add_visitor();
    printf("Here: %d, total: %d\n", visitors_here(), total_visitors);
    return 0;
}

gcc -std=c23 -Wall -Wextra main.c counter.c -o visitors
./visitors

Here: 2, total: 2

main.c can read total_visitors directly but can reach count only through the function visitors_here. If main.c tried extern int count;, the program would fail to link. Making helpers static is good practice: it keeps each file's internals hidden and avoids name clashes between files. In real projects, the extern declarations and prototypes go into a header file, as shown in Header Files & Multi-file Programs.

Common mistakes

• Using a variable outside its block. A variable declared inside an if or loop body disappears at the closing brace.
• Accidental shadowing. Declaring int total again inside a loop creates a new variable, and the outer total never changes.
• Expecting a local variable to remember its value. Without static, locals restart on every call.
• Too many globals. They make bugs hard to trace. Pass values through parameters instead.
• Defining the same global in two files. Define it once in one .c file and use extern everywhere else, or the linker reports a multiple definition.

Key points

• Scope is where a name can be used; lifetime is how long the memory exists.
• Local variables have block scope and automatic lifetime; they start fresh on each entry.
• Global variables have file scope, live for the whole run and start at zero.
• A static local is initialised once and keeps its value between calls.
• At file level, static makes a variable or function private to its file; extern declares one defined in another file.
• Prefer parameters and return values over global variables.

#include <stdio.h>

void record_sale(int amount)
{
    static int total = 0;
    total += amount;
    printf("Sale: Rs %d, total today: Rs %d\n", amount, total);
}

int main(void)
{
    record_sale(120);
    record_sale(80);
    record_sale(250);
    return 0;
}

Sale: Rs 120, total today: Rs 120
Sale: Rs 80, total today: Rs 200
Sale: Rs 250, total today: Rs 450