💾 Storage Classes in C

A storage class in C helps describe important properties associated with an identifier, such as its scope, storage duration, and, where relevant, linkage.

Understanding storage classes is essential when working with functions, multiple source files, global variables, recursion, static data, and larger C projects.

21.1 Why Storage Classes Matter

Consider these two variables:

int local = 10;

and:

static int count = 0;

Both are integers, but their behavior can be very different.

• A normal local variable generally has automatic storage duration.
• A static local variable retains its stored value between function calls.
• An external declaration can refer to an object defined elsewhere.
• register expresses a request to keep an object in a register when supported by the implementation, but it does not guarantee this.

21.2 The Four Traditional Storage-Class Specifiers

21.3 Scope, Lifetime, Storage Duration and Linkage

These terms are often mixed together. They describe different properties.

21.4 The Four Storage Durations

Allocated storage duration is covered more deeply in the Dynamic Memory Allocation topic. Thread storage duration is an advanced C feature and is outside the main focus of this lesson.

21.5 The auto Storage Class

The auto specifier indicates automatic storage duration for an object declared at block scope.

int main(void) { auto int x = 10; printf("%d\n", x); return 0; }

In ordinary modern C programming, the keyword auto is rarely written explicitly because block-scope variables already have automatic storage duration by default when no other storage-class specifier changes it.

21.6 Automatic Variables

This is more common:

int main(void) { int x = 10; printf("%d\n", x); return 0; }

Here x is an automatic-duration object because it is an ordinary block-scope local variable.

21.7 Example of Automatic Lifetime

void demo(void) { int x = 10; printf("%d\n", x); }

Each time demo() is entered, a new instance of the automatic object x is created for that execution of the block. Its storage duration ends when execution leaves the block.

21.8 Automatic Variables and Initialization

int main(void) { int a; int b = 20; printf("%d\n", b); return 0; }

b has a specified initial value. a does not. Reading a before giving it a valid value can produce undefined behavior in contexts where its indeterminate value is used inappropriately.

21.9 The register Storage Class

The register keyword historically expresses a request that an object be stored in a processor register if possible.

int main(void) { register int i; for (i = 0; i < 10; ++i) { printf("%d ", i); } return 0; }

21.10 Important Rule About register

A particularly important language rule is that you cannot apply the unary address-of operator to an object declared with the register storage-class specifier.

register int x = 10; /* Not allowed: */ int *p = &x;

The language specifically restricts taking the address of a register-declared object.

21.11 Should You Use register Today?

Usually, programmers should focus on writing clear code and let the compiler optimizer make register-allocation decisions.

The keyword remains part of the language, so it is still important for exams and for understanding older C code.

21.12 The static Storage Class

The keyword static has two especially important uses:

1. At block scope, it gives the object static storage duration.
2. At file scope, it gives an object or function internal linkage.

21.13 Static Local Variable

void counter(void) { static int count = 0; count++; printf("%d\n", count); }

If called three times:

counter(); counter(); counter();

the output is:

1 2 3

The local name count remains visible only inside the function, but the object retains its value between calls.

21.14 Static Local Variable Trace

 First call | ▼ count = 0 | ▼ count++ | ▼ prints 1 Second call | ▼ same static object | ▼ count = 1 | ▼ count++ | ▼ prints 2 Third call | ▼ count = 2 | ▼ count++ | ▼ prints 3 

21.15 Static Local vs Normal Local

21.16 Static Local Initialization

void demo(void) { static int x = 10; x += 5; printf("%d\n", x); }

Repeated calls produce:

15 20 25 

The initializer is not reapplied as though the object were newly created on every function call.

21.17 Static Local Variables in Recursion

Static local variables can produce behavior very different from automatic variables during recursion.

void countDown(int n) { static int calls = 0; calls++; if (n > 0) { countDown(n - 1); } printf("Calls = %d\n", calls); }

All recursive invocations refer to the same static object calls, not separate copies.

21.18 Static at File Scope

Consider:

static int counter = 0;

At file scope, this object has static storage duration and internal linkage.

That means declarations in other translation units cannot refer to this object by ordinary external linkage.

21.19 Static File-Scope Function

static void helper(void) { printf("Internal helper\n"); }

A file-scope function declared static has internal linkage. It is intended to be usable within that translation unit rather than exported through external linkage.

21.20 Why File-Scope Static Is Useful

• Hides implementation details from other source files.
• Reduces accidental name collisions across translation units.
• Helps create private helper functions and private file-level objects.
• Makes module boundaries clearer.

21.21 Internal vs External Linkage

21.22 What Is a Translation Unit?

A translation unit is essentially the source file after preprocessing, including the relevant contents brought in through preprocessing directives.

 source.c | | preprocessing v translation unit | | compilation v object file | | linking v executable 

21.23 The extern Storage Class

The extern keyword is commonly used to declare that an object or function is defined elsewhere.

Example:

extern int total;

This declaration says that total is an object with external linkage and that its definition is provided elsewhere, subject to the applicable language rules.

21.24 Declaration vs Definition

This distinction is critical when learning extern.

extern int total;

is normally a declaration that does not define the object.

Whereas:

int total = 100;

is a definition of the object.

21.25 Multi-File Example

counter.c

int total = 100;

main.c

#include <stdio.h> extern int total; int main(void) { printf("%d\n", total); return 0; }

The definition of total is in one translation unit and its declaration is visible in the other.

21.26 Header Files and extern

In a multi-file project, an external declaration is often placed in a header.

config.h

#ifndef CB_CONFIG_H #define CB_CONFIG_H extern int total; #endif

config.c

#include "config.h" int total = 100;

main.c

#include <stdio.h> #include "config.h" int main(void) { printf("%d\n", total); return 0; }

21.27 Do Not Define Ordinary Global Objects Repeatedly in Headers

A common mistake is putting an ordinary external definition directly into a header:

/* Bad header design */ int total = 100;

If that header is included by multiple translation units, multiple definitions of the same external object can cause linker errors.

A common pattern is:

/* header */ extern int total; /* exactly one .c file */ int total = 100;

21.28 Static vs Extern

21.29 Static Function vs Normal Function

static void calculate(void) { /* private helper */ }

Compared with:

void calculate(void) { /* externally linked function */ }

At file scope, static gives the function internal linkage. A normal file-scope function definition normally has external linkage unless another rule changes it.

21.30 Static Does Not Mean Constant

It does not.

static int count = 0; count++; count++; 

The value can change normally.

If you want an object that cannot be modified through its declared type, const is relevant.

21.31 Static Does Not Mean Global

Consider:

void demo(void) { static int x = 10; }

The object has static storage duration, but its identifier has block scope. It is not a globally visible variable.

21.32 Static Initialization

Objects with static storage duration are initialized before program startup according to C's initialization rules.

static int a; static int b = 20;

If no initializer is supplied, an object with static storage duration is initialized to zero (or the appropriate null/zero representation for its type).

21.33 Automatic vs Static Initialization

21.34 Storage Class and Scope Are Different

Consider:

int global; void demo(void) { int local; static int persistent; }

21.35 Storage Class and Memory Location

A beginner-friendly diagram might show:

 Program Memory │ ┌──────────────┼──────────────┐ │ │ │ ▼ ▼ ▼ Static-duration Automatic Allocated objects objects objects │ │ │ │ │ │ global/static local data malloc/calloc objects in blocks /realloc 

This is a conceptual model, not a guarantee of a specific physical memory layout. The C language defines behavior and storage duration; the exact machine-level arrangement is implementation-dependent.

21.36 Storage Classes and Functions

Storage-class specifiers also appear in function declarations and definitions, but their meaning must be interpreted according to context.

The most common example is:

static void helper(void) { }

where static at file scope gives the function internal linkage.

21.37 The extern Keyword With Functions

Functions normally have external linkage unless their declaration is made static.

Therefore an explicit:

extern void display(void);

can declare an externally linked function defined elsewhere.

Because external linkage is the normal case for ordinary file-scope functions, explicit extern is often unnecessary for function declarations.

21.38 Storage-Class Specifiers vs Type Qualifiers

21.39 What About _Thread_local?

Modern C also provides the _Thread_local storage-class specifier for objects whose storage duration is associated with a thread.

_Thread_local int thread_count;

Each thread can have its own instance of the object.

This is an advanced topic and is mainly relevant to multithreaded C programs.

21.40 Complete Comparison

21.41 Example — Four Concepts Together

#include <stdio.h> int global_value = 100; static int private_value = 200; void demo(void) { int local_value = 10; static int persistent_value = 0; persistent_value++; printf("%d %d %d %d\n", global_value, private_value, local_value, persistent_value); } int main(void) { demo(); demo(); return 0; }

Important observations:

• global_value has static storage duration and external linkage.
• private_value has static storage duration and internal linkage.
• local_value has automatic storage duration.
• persistent_value has static storage duration but block scope.

21.42 Program Trace

 Program starts global_value = 100 private_value = 200 persistent_value = 0 | ▼ First demo() local_value = 10 persistent_value++ persistent_value = 1 Output: 100 200 10 1 | ▼ demo() ends local_value disappears persistent_value remains 1 | ▼ Second demo() new local_value = 10 persistent_value++ persistent_value = 2 Output: 100 200 10 2 

21.43 Why Does Static Local Remember?

The key is storage duration.

static int count = 0;

The object continues to exist after the function block finishes, even though the identifier count is only usable within that block.

 Scope ────────────────────────────── function block only Storage duration ────────────────────────────── entire program execution Therefore: name is local object lifetime is persistent 

21.44 Static Local Counter Pattern

This is a common practical pattern:

int next_id(void) { static int id = 1000; return id++; }

Repeated calls return:

1000 1001 1002 1003 ...

This pattern can be useful for maintaining state without exposing the variable as a global object.

21.45 Static Function for Module Encapsulation

static int square(int x) { return x * x; }

If the function is defined at file scope with static, it is private to that translation unit in terms of linkage.

This is useful for helper functions that should not become part of a module's external interface.

21.46 A Typical Header/Source Design

student.h

#ifndef CB_STUDENT_H #define CB_STUDENT_H typedef struct { int id; char name[50]; } Student; void printStudent(const Student *student); #endif

student.c

#include <stdio.h> #include "student.h" static void printSeparator(void) { printf("----------------\n"); } void printStudent(const Student *student) { printSeparator(); printf("ID: %d\n", student->id); printf("Name: %s\n", student->name); }

Here printSeparator() is a private helper because it is file-scope static.

21.47 Why This Design Is Useful

• The header exposes the public interface.
• The source file contains the implementation.
• The static helper is hidden from other translation units.
• Other files can use printStudent() through the header.

21.48 Common Storage-Class Mistakes

• Thinking static always means global.
• Thinking static means constant.
• Thinking register guarantees a CPU register.
• Thinking auto initializes local variables to zero.
• Thinking extern creates the actual global object.
• Defining the same external object in multiple source files.
• Putting ordinary external variable definitions in widely included headers.
• Confusing scope with storage duration.
• Confusing storage duration with physical RAM location.
• Assuming a static local variable becomes globally accessible.

21.49 Common Confusions

21.50 Storage Classes and Recursion

Consider a normal recursive function:

void recurse(int n) { int local = n; if (n > 0) recurse(n - 1); }

Each active invocation has its own automatic local object.

With:

static int local;

there is one static object shared by all invocations of the function.

 Automatic recursion: Call 1 → local A Call 2 → local B Call 3 → local C Static recursion: Call 1 ─┐ Call 2 ─┼──► one static object Call 3 ─┘ 

21.51 Storage Duration Is Not Stack/Heap Terminology

You may hear programmers say:

automatic = stack allocated = heap static = data segment 

These are useful implementation-level mental models, but they are not the complete language definition.

21.52 Interview Question — static Local

#include <stdio.h> void test(void) { static int x = 0; x++; printf("%d ", x); } int main(void) { test(); test(); test(); return 0; }

Output:

1 2 3

Reason: the same static object persists between calls.

21.53 Interview Question — Automatic Local

#include <stdio.h> void test(void) { int x = 0; x++; printf("%d ", x); } int main(void) { test(); test(); test(); return 0; }

Output:

1 1 1

The automatic local object is initialized to zero for each invocation.

21.54 Interview Question — File-Scope static

static int count = 10;

At file scope, count has internal linkage. Another translation unit cannot access that object through an ordinary external declaration of the same identifier.

21.55 Interview Question — extern

Suppose:

/* file1.c */ int value = 50;

and:

/* file2.c */ extern int value;

The second declaration allows code in file2.c to refer to the externally linked object defined in file1.c.

21.56 Interview Question — register Address

register int x = 10; printf("%p", (void *)&x);

This is not valid C because the address of a register-declared object cannot be taken.

21.57 Storage Class Decision Tree

 Do you need ordinary local state? | ├── Yes → automatic object | ▼ Do you need local state to survive function calls? | ├── Yes → static local | ▼ Do you want a file-private object/function? | ├── Yes → file-scope static | ▼ Do you need to refer to an external definition? | ├── Yes → extern declaration | ▼ Do not use register merely to force optimization. Let the compiler optimize. 

21.58 Best Practices

22.15 Quick Revision

INTERACTIVE LEARNING

🎬 Storage Classes — Scope, Lifetime & Linkage

Compare the key idea behind auto, register, static, and extern.

▶ Open Visualization

—

22.16 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the answer is wrong, your choice becomes red and the correct option becomes green. The explanation appears below.

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("auto: block-scope local object with automatic storage duration");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    auto int value;
    scanf("%d", &value);
    value += 10;
    printf("%d", value);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("register: local variable hint; actual register use is implementation-controlled");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    int n;
    int sum = 0;
    register int i;

    scanf("%d", &n);

    for (i = 1; i <= n; i++)
        sum += i;

    printf("%d", sum);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("register is a language hint; the implementation decides actual storage");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

void show(void)
{
    static int count = 0;
    count++;
    printf("%d", count);
}

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

Run your program to see the output.

#include <stdio.h>

int callCounter(void)
{
    static int count = 0;
    return ++count;
}

int main()
{
    int n;
    int result = 0;
    scanf("%d", &n);

    for (int i = 0; i < n; i++)
        result = callCounter();

    printf("%d", result);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

void show(void)
{
    int automatic = 0;
    static int persistent = 0;

    automatic++;
    persistent++;

    printf("%d %d\n", automatic, persistent);
}

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

Run your program to see the output.

#include <stdio.h>

static int total = 10;

int main()
{
    int x;
    scanf("%d", &x);
    total += x;
    printf("%d", total);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("internal linkage: the file-scope name is confined to its translation unit");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

extern int shared;
int shared = 25;

int main()
{
    printf("%d", shared);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

/* file1.c concept: definition */
int shared = 100;

/* file2.c concept: declaration */
extern int shared;

int main()
{
    int x;
    scanf("%d", &x);
    shared += x;
    printf("%d", shared);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("Scope: where a name can be used.\n");
    printf("Lifetime: how long an object exists.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int nextValue(void)
{
    static int value = 0;
    value += 2;
    return value;
}

int main()
{
    int a = nextValue();
    int b = nextValue();
    int c = nextValue();

    printf("%d %d %d", a, b, c);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("ordinary local: automatic\n");
    printf("static local: static\n");
    printf("file-scope object: static");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("Do not read an uninitialized automatic object; initialize it before use.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main()
{
    printf("static local: block scope, static storage duration.\n");
    printf("static file-scope: file scope, static storage duration, internal linkage.");
    return 0;
}

Run your program to see the output.

#include <stdio.h>

/* config.h concept */
extern int config;

/* config.c concept */
int config = 42;

/* main.c concept */
int main()
{
    printf("%d", config);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

static int square(int x)
{
    return x * x;
}

int main()
{
    int x;
    scanf("%d", &x);
    printf("%d", square(x));
    return 0;
}

Run your program to see the output.

#include <stdio.h>

/* Shared-object concept */
extern int shared;
int shared = 10;

int calls(void)
{
    static int count = 0;
    return ++count;
}

int main()
{
    auto int n;
    register int i;
    int sum = 0;

    scanf("%d", &n);

    for (i = 1; i <= n; i++)
        sum += i;

    int callCount = calls();
    shared += sum;

    printf("sum=%d calls=%d shared=%d", sum, callCount, shared);
    return 0;
}

22.18 Interview Questions

22.19 Key Takeaway