Storage Classes

What is a storage class?

When you declare a variable in C, the compiler needs to know more than just its type. It needs to know where the variable can be used, how long it should stay alive in memory, and what value it starts with if you do not set one. A storage class answers exactly these three questions.

So every variable has three properties tied to its storage class:

• Scope — the region of code where the variable is visible.
• Lifetime — how long the variable exists in memory.
• Default value — what it holds if left uninitialised.

C gives you four storage-class keywords to set these: auto, register, static and extern.

The four storage classes at a glance

Now let's look at each one with a working example.

auto — the default local

Any variable you declare inside a function is automatically auto. Writing the keyword is optional and adds nothing — which is why you almost never see it in real code.

#include <stdio.h>
int main() {
    auto int x = 10;   // same as: int x = 10;
    int y = 20;        // y is also auto by default
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

register — a speed hint

The register keyword requests that a variable be kept in a CPU register instead of RAM, which is faster to access. It is only a request: the compiler may ignore it. A common use was tight loop counters.

#include <stdio.h>
int main() {
    register int i;
    for (i = 1; i <= 3; i++)
        printf("%d ", i);
    return 0;
}

static — remembers its value

This is the most useful storage class. A static local variable is initialised only once and keeps its value across function calls, because its lifetime is the whole program — not a single call.

#include <stdio.h>
void counter() {
    static int count = 0;   // set once, survives calls
    count++;
    printf("Call number: %d\n", count);
}
int main() {
    counter();
    counter();
    counter();
    return 0;
}

If count were an ordinary local variable, it would reset to 0 on every call and always print 1. Being static is what lets it count.

extern — shared across files

Large programs are split across several .c files. When one file needs a global variable that is defined in another file, it uses extern to say "this exists elsewhere, trust me."

#include <stdio.h>
int score = 100;        // actual definition

void show(void);        // from file2.c

int main() {
    show();
    return 0;
}

#include <stdio.h>
extern int score;       // declared here, defined in file1.c

void show(void) {
    printf("Score = %d\n", score);
}

Scope, lifetime & default value

Common mistakes

• Expecting an ordinary local variable to remember its value between calls — you need static for that.
• Trying to take the address of a register variable with &.
• Using extern and also initialising the variable in the same line in every file — only one file should define it.
• Assuming auto variables start at 0 — they hold garbage until initialised.

Summary

• A storage class sets a variable's scope, lifetime and default value.
• auto is the default for locals — you never need to write it.
• register hints at CPU-register storage; it is obsolete today.
• static keeps a local's value across calls, and hides globals inside a file.
• extern lets one file use a global defined in another file.