💾 22. 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.

Use this lesson to answer three questions about a variable: where can its name be used, how long does its object exist, and can declarations in other files refer to the same object?

22.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.

22.2 The Four Traditional Storage-Class Specifiers

22.3 Scope, Lifetime, Storage Duration and Linkage

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

22.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.

22.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 usually omitted for ordinary local variables. This section uses its traditional C17 meaning. C23 also supports type inference with auto, which is a separate newer use.

22.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.

22.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.

22.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 assigning a valid value is a mistake. A local declaration without an initializer is not a request to start the object at zero.

22.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; }

22.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.

22.11 Should You Use register Today?

Write clear code and measure performance when needed. The compiler can choose registers without a register declaration.

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

22.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.

22.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.

22.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 

22.15 Static Local vs Normal Local

22.16 Static Local Initialization

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

Repeated calls produce:

15 20 25 

The static initializer is applied once. Later calls continue with the stored value left by earlier calls; they do not restart it from the initializer.

22.17 Static Local Variables in Recursion

During recursion, distinguish a new automatic variable in each call from a single static variable shared by the calls.

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.

22.18 Static at File Scope

Consider:

static int counter = 0;

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

The file-scope name has internal linkage. Another source file cannot use an ordinary extern declaration of that name to refer to this object. This restricts name linkage, not every possible access through a pointer.

22.19 Static File-Scope Function

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

A file-scope function declared static has internal linkage. Other translation units cannot refer to it through an ordinary external declaration of the same name. It is useful as a private helper within a module.

22.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.

22.21 Internal vs External Linkage

22.22 What Is a Translation Unit?

For this lesson, think of a translation unit as a source file after preprocessing, including the header contents selected by its include directives.

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

22.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 refers to a shared object. In this example there is no earlier declaration changing its linkage, so it has external linkage. Provide one matching definition in the program when it is used.

22.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.

22.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.

22.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;
}

22.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;

An include guard does not prevent this problem across translation units: each source file can still get its own external definition from the header. Use an extern declaration in the header and one definition in a source file.

A common pattern is:

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

22.28 Static vs Extern

22.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.

22.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.

22.31 Static Does Not Mean Global

Consider:

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

The name is still local to its block. The object survives between calls, but code outside that scope cannot use the local name directly.

22.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;

Without an explicit initializer, arithmetic members receive zero values and pointer members receive null pointer values according to their types. This is not a rule that every object is represented by all-zero bytes.

22.33 Automatic vs Static Initialization

22.34 Storage Class and Scope Are Different

Consider:

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

22.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 

The diagram is a learning model. C specifies lifetime and linkage rules; it does not require every automatic object to be on a hardware stack or every static object to occupy a particular named memory segment.

22.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.

22.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.

22.38 Storage-Class Specifiers vs Type Qualifiers

22.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.

22.40 Complete Comparison

22.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.

22.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 

22.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 

22.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 ...

The function keeps its own running state between calls. Because that state persists, repeated tests or concurrent calls need to account for earlier updates.

22.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.

22.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.

22.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.

22.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.

22.49 Common Confusions

22.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 ─┘ 

22.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.

22.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.

22.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.

22.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.

22.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.

22.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.

22.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. 

22.58 Best Practices

#include <stdio.h>

_Thread_local int perThreadCount = 0;

int main(void)
{
    ++perThreadCount;
    printf("Count = %d\n", perThreadCount);
    return 0;
}

Count = 1

22.60 Quick Revision

INTERACTIVE LEARNING

🎬 Storage Classes — Scope, Lifetime & Linkage

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

▶ Open Visualization

—

22.61 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.63 Interview Questions

22.64 Key Takeaway