Understanding C Storage Classes: Scope, Lifetime, and Performance

Understanding C Storage Classes

Explore how automatic, external, static, and register storage classes define a variable’s scope, lifetime, and performance in C.

Automatic (Local) Variables

Variables declared inside a block are automatic, also known as local variables. They exist only within that block and are destroyed when the block ends.

#include <stdio.h>

int main(void) {
    for (int i = 0; i < 5; ++i) {
        printf("C programming\n");
    }
    // Error: i is not declared in this scope
    printf("%d", i);
    return 0;
}

Running this program results in an undeclared identifier i error because i is declared only inside the for loop block.

int main() {
    int n1; // local to main()
}

void func() {
    int n2; // local to func()
}

Here, n1 is inaccessible inside func(), and n2 is inaccessible inside main().

Global (External) Variables

Variables declared outside all functions are global or external. They can be accessed from any function within the same translation unit. When a global variable is defined in one file but used in another, the extern keyword signals that the definition resides elsewhere.

Example: Global Variable

#include <stdio.h>

void display();

int n = 5;  // global variable

int main() {
    ++n;
    display();
    return 0;
}

void display() {
    ++n;
    printf("n = %d\n", n);
}

Output

n = 7

If n is defined in file1.c and used in file2.c, add extern int n; at the top of file2.c to avoid a compilation error.

Register Variables

The register keyword hints that the compiler should store the variable in a CPU register to speed access. Modern compilers perform aggressive optimization, often rendering the hint unnecessary. Use register only when profiling indicates a critical bottleneck on embedded systems.

Static Variables

Static variables are declared with static and retain their value for the entire program execution. They are initialized only once, at program startup, and remain in existence until program termination.

Example: Static Variable

#include <stdio.h>

void display();

int main() {
    display();
    display();
}

void display() {
    static int c = 1;
    c += 5;
    printf("%d  ", c);
}

Output

6 11

On the first call, c is initialized to 1, then increased to 6. On the second call, c retains its previous value of 6, is increased to 11, and printed.

At file scope, a static declaration gives the variable internal linkage, making it invisible to other translation units—a useful feature for encapsulation.

According to the ISO C standard, the behavior of static ensures a single instance across all function calls, which is critical for stateful operations without global pollution.