Understanding Storage Classes in C: auto, extern, static, register Explained

What Is a Storage Class in C?

A storage class defines a variable’s scope, location, initialization, lifetime, and accessibility. In C, every variable is not only typed but also assigned a storage class that determines where and how it can be accessed.

There are four standard storage classes:

• auto – default for local variables.
• extern – declares a global variable or function that exists in another file.
• static – preserves a variable’s value between calls and limits visibility to a file or function.
• register – hints the compiler to store a variable in a CPU register for faster access.

Auto Storage Class

Variables declared with auto (the default for local variables) exist only within the block they are defined in. They are destroyed when the block exits, and they are initialized with an indeterminate value unless explicitly set.

int add(void) {
    int a = 13;
    auto int b = 48;  // auto is optional
    return a + b;
}

Scope demonstration:

#include <stdio.h>
int main(void) {
    auto int j = 1;
    {
        auto int j = 2;
        {
            auto int j = 3;
            printf("%d ", j);  // prints 3
        }
        printf("\t%d ", j);  // prints 2
    }
    printf("%d\n", j);  // prints 1
}

Output: 3 2 1

Extern Storage Class

The extern keyword declares a variable or function that is defined in another translation unit. It enables data sharing across source files.

/* main.c */
#include <stdio.h>
extern int i;  // declaration
int main(void) {
    printf("value of the external integer is = %d\n", i);
    return 0;
}

/* original.c */
#include <stdio.h>
int i = 48;   // definition

Compile both files together: gcc main.c original.c -o program. Running ./program outputs:

value of the external integer is = 48

Static Storage Class

Static variables retain their value for the duration of the program. They can be used as local statics or file‑scope statics.

• Local static – visible only inside the function but persists across calls.
• File‑scope static – visible only within the file where declared.

/* global static */
static int counter = 7;

void next(void) {
    /* local static */
    static int iteration = 13;
    iteration++;
    printf("iteration=%d and counter=%d\n", iteration, counter);
}

int main(void) {
    while (counter < 10) {
        next();
        counter++;
    }
    return 0;
}

Output:

iteration=14 and counter=7
iteration=15 and counter=8
iteration=16 and counter=9

Register Storage Class

Use register when a variable needs to be accessed frequently and can fit in a CPU register. The compiler may ignore the hint if registers are scarce.

#include <stdio.h>
int main(void) {
    register int weight;
    /* attempting to take its address fails */
    // int *ptr = &weight;  // compilation error
    return 0;
}

Compiling the code yields:

error: address of register variable 'weight' requested

Summary Table

Key Takeaways

• Storage classes control visibility and lifetime of variables.
• Use auto for standard local variables.
• Use register for performance‑critical counters (subject to compiler support).
• Use static to preserve state across function calls or to limit file scope.
• Use extern to share variables or functions between source files.