C Storage Classes

Types of Storage Classes

auto int x = 10;
// Same as: int x = 10;

static int count = 0;
// Persists between calls

extern int global_var;
// Declared elsewhere

register int fast = 100;
// Hint for fast access

🔹 auto Storage Class

The auto storage class is the default for local variables, existing on the stack with automatic memory management. Variables declared with auto or simply without explicit storage class are automatically allocated when entering their scope and deallocated when exiting. Stack allocation provides fast access but limited memory compared to heap allocation. Most local variables implicitly use auto storage, making explicit declaration unnecessary in modern C practice.

#include <stdio.h>

void demo_auto() {
    auto int count = 0;  // Explicitly using auto
    int value = 10;      // Implicitly auto
    
    count++;
    value += 5;
    
    printf("Auto count: %d\n", count);
    printf("Auto value: %d\n", value);
    
    // Variables are destroyed when function ends
}

int main() {
    printf("First call:\n");
    demo_auto();
    
    printf("Second call:\n");
    demo_auto();  // Variables reset each time
    
    printf("Third call:\n");
    demo_auto();
    
    return 0;
}

First call:
Auto count: 1
Auto value: 15
Second call:
Auto count: 1
Auto value: 15
Third call:
Auto count: 1
Auto value: 15

🔹 static Storage Class

The static storage class maintains variable values between function calls, creating persistent local variables. Static variables are initialized only once at program start and retain their values across multiple function invocations. Use static int counter = 0; to create counters or accumulators maintaining state. Static variables exist throughout program lifetime but remain locally scoped. This feature enables implementing stateful functions without using global variables.

#include <stdio.h>

void demo_static() {
    static int persistent_count = 0;  // Initialized only once
    auto int temporary_count = 0;     // Reset each call
    
    persistent_count++;
    temporary_count++;
    
    printf("Static count: %d\n", persistent_count);
    printf("Auto count: %d\n", temporary_count);
}

static int file_scope_var = 100;  // File scope static

int main() {
    printf("File scope static: %d\n", file_scope_var);
    
    printf("\nFunction calls:\n");
    demo_static();
    demo_static();
    demo_static();
    
    return 0;
}

File scope static: 100

Function calls:
Static count: 1
Auto count: 1
Static count: 2
Auto count: 1
Static count: 3
Auto count: 1

🔹 extern Storage Class

The extern keyword declares that a variable is defined elsewhere, enabling access to external variables. Use extern int globalVar; to reference variables defined in other source files or earlier in your program. extern declarations don't allocate memory; they inform the compiler about existing variables. This mechanism enables modular programming by sharing data across compilation units while maintaining proper variable definition practices.

#include <stdio.h>

// Global variable definition
int shared_data = 500;
int another_global = 750;

void function_one() {
    extern int shared_data;  // Reference to global
    extern int another_global;
    
    printf("Function 1 - Shared: %d\n", shared_data);
    shared_data += 50;
    another_global += 25;
}

void function_two() {
    // Global variables are accessible without extern
    printf("Function 2 - Shared: %d\n", shared_data);
    printf("Function 2 - Another: %d\n", another_global);
}

int main() {
    printf("Initial values:\n");
    printf("Shared data: %d\n", shared_data);
    printf("Another global: %d\n", another_global);
    
    function_one();
    function_two();
    
    printf("\nFinal values:\n");
    printf("Shared data: %d\n", shared_data);
    printf("Another global: %d\n", another_global);
    
    return 0;
}

Initial values:
Shared data: 500
Another global: 750
Function 1 - Shared: 500
Function 2 - Shared: 550
Function 2 - Another: 775

Final values:
Shared data: 550
Another global: 775

🔹 register Storage Class

The register keyword suggests storing variables in CPU registers for faster access than memory. Use register int i; for frequently accessed variables in performance-critical loops. The compiler may ignore this hint if registers unavailable, treating it as a regular variable. Modern optimizing compilers typically handle register allocation better than manual hints. The keyword remains available for specific optimization scenarios where compiler hinting provides performance benefits.

#include <stdio.h>

int main() {
    register int loop_counter;  // Suggest register storage
    register int fast_calc = 0;
    int normal_var = 100;
    
    printf("Using register variables for performance:\n");
    
    // Fast loop using register variable
    for (loop_counter = 1; loop_counter <= 5; loop_counter++) {
        fast_calc += loop_counter * 2;
        printf("Loop %d: fast_calc = %d\n", loop_counter, fast_calc);
    }
    
    printf("Normal variable: %d\n", normal_var);
    
    // Note: Cannot take address of register variables
    // printf("Address: %p", &loop_counter);  // This would cause error
    
    return 0;
}

Using register variables for performance:
Loop 1: fast_calc = 2
Loop 2: fast_calc = 6
Loop 3: fast_calc = 12
Loop 4: fast_calc = 20
Loop 5: fast_calc = 30
Normal variable: 100