In the C programming language, a storage class defines the scope (visibility) and life-time of variables and/or functions within a program. There are four fundamental storage classes that can be used to define these properties: auto, register, static, and extern.

1. Auto

The auto storage class is the default storage class for local variables within functions. The keyword auto is optional in modern C standards, as it is implied for local variables. Local variables that are declared without any storage class specifier are considered auto by default. They are allocated memory on the stack and have automatic storage duration, which means they are created when the block (function or other scope) is entered and destroyed when the block is exited.

1
2
3
4
5
6

void func() {
  /*
   * Implicitly 'auto', can be omitted
   */
  auto int localVar = 10;
}

2. Register

The register storage class is used to suggest to the compiler that a variable should be stored in a CPU register instead of RAM for faster access. However, this suggestion is not guaranteed and depends on the hardware capabilities and implementation details of the compiler. Registers are typically used for frequently accessed variables where speed is critical.

1
2
3
4

/*
 * Compiler may choose to store 'fastVar' in a register
 */
register int fastVar = 42;

3. Static

The static storage class can be applied to local variables, global variables, and function parameters/arguments:

• For local variables within functions, static extends the lifetime of the variable beyond its scope (block), keeping it alive across multiple function calls until the program terminates.
• For global variables and functions, static restricts the visibility to the file in which they are defined. This means that these entities cannot be accessed outside their source file.

1
2
3
4
5
6
7

void func() {
    /*
     * The value of 'count' persists across function calls
     */
    static int count = 0;
    count++;
}

4. Extern

The extern storage class is used to declare a variable or function that is defined in another source file (or other part of the same program). It merely declares the name and type of the variable/function, but does not allocate memory for it. The actual definition can be found in another file using this keyword.

1
2
3
4
5

// file1.c:
/*
 * Declare a variable that is defined elsewhere
 */
extern int globalVar;

1
2
3
4
5

// file2.c:
/*
 * Define the variable
 */
int globalVar = 42;

Hands on Example

Here’s an example code snippet demonstrating all four storage classes in action:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include <stdio.h>

/*
 * Global variable with static storage, internal linkage
 */
static int g_staticVar = 0;

/*
 * External declaration (default linkage)
 */
int g_externVar;

void func() {
    /*
     * Local variable with auto storage (implicitly so)
     */
    auto int localAuto = 1;

    /*
     * Register suggested storage for fast access
     */
    register char fastAccess;

    /*
     * Static within function scope,
     * retains its value between calls
     */
    static int count = 0;
    count++;

    printf("Local Auto: %d, Count: %d, Global External: %d\n", localAuto, count, g_externVar);
}

int main() {
    /*
     * Initialize external variable defined
     * in another file or scope
     */
    g_externVar = 10;

    /*
     * Call the function several times to see changes
     * due to static and auto storage
     */
    func();
    func();

    return 0;
}

This code snippet shows how auto, register, static, and extern can be used in different contexts within a C program. Each of these keywords significantly influences how memory is managed and accessed throughout the lifetime of a variable or function.