Functions

Scope & Storage Classes

Master variable scope (local, global, block), storage classes (auto, static, extern, register), and lifetime. Understand visibility rules and memory management for variables.

Understanding Scope

Scope defines where in a program a variable is visible and accessible. C has several scope levels: block scope (within { }), function scope (parameters and labels), file scope (global to translation unit), and function prototype scope. Understanding scope prevents naming conflicts, controls access to data, and helps manage program complexity by limiting variable visibility.

Variables declared inside a block exist only within that block. Variables declared outside all functions have file scope and are accessible throughout the file (and potentially other files with extern). The scope rules determine which variables are "in scope" at any point in your code.

C
#include <stdio.h>

/* File scope (global variable) */
int global_count = 0;

void function1(void) {
    /* Local variable (function/block scope) */
    int local_var = 10;
    printf("local_var: %d\n", local_var);
    printf("global_count: %d\n", global_count);  // Can access global
}

void function2(void) {
    // printf("%d\n", local_var);  // ERROR: local_var not visible here
    printf("global_count: %d\n", global_count);  // Can access global
}

int main(void) {
    /* Block scope */
    {
        int x = 5;  // x exists only in this block
        printf("x: %d\n", x);
    }
    // printf("%d\n", x);  // ERROR: x not visible here
    
    global_count = 42;  // Modify global
    function1();
    function2();
    
    return 0;
}

Local vs. Global Variables

Local variables are declared inside functions or blocks and only visible within that scope. They're created when their block executes and destroyed when it exits. Global variables are declared outside all functions and visible throughout the file (and potentially across files). Globals persist for the program's lifetime but make code harder to understand and test.

C
#include <stdio.h>

/* Global variables (file scope) */
int global_x = 100;
char global_name[50] = "Global";

void modify_global(void) {
    global_x += 10;  // Can modify global
    printf("Global x: %d\n", global_x);
}

void use_local(void) {
    /* Local variables */
    int local_x = 50;
    char local_name[50] = "Local";
    
    printf("Local x: %d\n", local_x);
    printf("Global x: %d\n", global_x);
    
    /* Local shadows global */
    int global_x = 200;  // Different variable!
    printf("Shadowed x: %d\n", global_x);  // 200 (local)
}

int main(void) {
    printf("Initial global_x: %d\n", global_x);  // 100
    
    modify_global();  // Changes global to 110
    printf("After modify: %d\n", global_x);  // 110
    
    use_local();
    printf("After use_local: %d\n", global_x);  // Still 110
    
    return 0;
}

/* Advantages of local variables */
// - Isolated: Can't be modified unexpectedly
// - Reusable: Same name in different functions OK
// - Memory efficient: Created/destroyed as needed

/* Disadvantages of global variables */
// - Hard to track modifications
// - Can't have same name in different files without conflicts
// - Make testing difficult (hidden dependencies)
// - Reduce code reusability

Storage Classes

Storage classes specify a variable's scope, lifetime, and linkage. C has four storage class specifiers: auto (default for local variables), static (persistent local or file-only global), extern (declares variable defined elsewhere), and register (hint for CPU register storage). Understanding storage classes gives precise control over variable behavior.

auto Storage Class

Auto is the default storage class for local variables. It's rarely written explicitly. Auto variables are created when their block begins execution and destroyed when it ends. They're stored on the stack.

C
void example_auto(void) {
    auto int x = 10;  // 'auto' is implicit, rarely written
    int y = 20;       // Same as 'auto int y = 20'
    
    printf("%d %d\n", x, y);
    
    /* x and y destroyed when function returns */
}

/* auto variables are NOT initialized by default */
void uninitialized_auto(void) {
    int x;  // Contains garbage!
    printf("%d\n", x);  // Undefined behavior
}

/* Each call creates new auto variables */
void increment_auto(void) {
    int count = 0;
    count++;
    printf("count: %d\n", count);  // Always prints 1
}

int main(void) {
    increment_auto();  // Prints 1
    increment_auto();  // Prints 1 again (new variable)
    increment_auto();  // Prints 1 again
    return 0;
}

static Storage Class

Static has two uses: static local variables (persist between function calls) and static global variables (visible only in current file). Static variables are initialized once and retain their values for the program's lifetime. They're stored in the data segment, not the stack.

C
#include <stdio.h>

/* Static local variable */
void increment_static(void) {
    static int count = 0;  // Initialized ONCE, persists
    count++;
    printf("count: %d\n", count);
}

int main(void) {
    increment_static();  // Prints 1
    increment_static();  // Prints 2
    increment_static();  // Prints 3 (persists!)
    return 0;
}

/* Static global variable (file scope only) */
static int file_private = 42;  // Not visible to other files

static void helper_function(void) {  // Not visible to other files
    printf("Helper\n");
}

/* Without static, visible to other files via extern */
int shared_variable = 100;  // Other files can use this

/* Common use: Module-level data */
// module.c:
static int connection_count = 0;  // Private to this file

void connect(void) {
    connection_count++;
}

int get_connection_count(void) {
    return connection_count;  // Controlled access
}

/* Static initialization */
void initialization_demo(void) {
    static int x;          // Initialized to 0 automatically
    static int y = 5;      // Explicit initialization
    static int z[100];     // Array initialized to all zeros
    
    printf("x: %d, y: %d\n", x, y);
}

extern Storage Class

Extern declares a variable defined in another file or later in the current file. It tells the compiler "this variable exists, but is defined elsewhere." Extern enables sharing global variables across multiple source files. Function declarations are extern by default.

C
/* file1.c */
int shared_value = 100;  // Definition

void set_value(int val) {
    shared_value = val;
}

/* file2.c */
extern int shared_value;  // Declaration (no definition!)

void print_value(void) {
    printf("%d\n", shared_value);  // Uses variable from file1.c
}

/* main.c */
extern int shared_value;  // Declaration
extern void set_value(int);  // Function declaration (extern is default)

int main(void) {
    printf("Initial: %d\n", shared_value);  // 100
    set_value(200);
    printf("Modified: %d\n", shared_value);  // 200
    print_value();  // 200
    return 0;
}

/* Important distinction */
int x;             // Definition (allocates memory)
extern int x;      // Declaration (doesn't allocate)

extern int y = 10;  // Definition (initialization makes it a definition)

/* Common pattern: Header file */
// config.h:
extern int max_connections;  // Declaration
extern int timeout;

// config.c:
int max_connections = 100;   // Definition
int timeout = 30;

// other.c:
#include "config.h"
// Now can use max_connections and timeout

register Storage Class

Register suggests storing a variable in a CPU register for fast access. It's a hint; the compiler can ignore it. You cannot take the address of a register variable. Register is rarely used in modern C - compilers optimize better than manual register hints.

C
void example_register(void) {
    register int counter;  // Suggestion to use CPU register
    
    for (counter = 0; counter < 1000000; counter++) {
        // Fast access (if compiler honors request)
    }
    
    // printf("%p\n", &counter);  // ERROR: Can't take address of register
}

/* When register might help (rarely) */
void intensive_loop(void) {
    register int i, j;  // Loop counters
    register int *ptr;  // Frequently accessed pointer
    
    for (i = 0; i < 1000; i++) {
        for (j = 0; j < 1000; j++) {
            // Heavy computation
        }
    }
}

/* Modern reality */
// Compilers usually ignore 'register' and optimize automatically
// Don't use unless profiling shows benefit
// Most compilers generate better code without it

Variable Lifetime

Lifetime is how long a variable exists in memory. Auto variables live from block entry to exit (stack allocation). Static and global variables live for the entire program execution (static/global storage). Understanding lifetime prevents accessing destroyed variables and helps manage memory efficiently.

C
#include <stdio.h>

/* Global: Lifetime = entire program */
int global = 100;

void lifetime_demo(void) {
    /* Auto: Created on each call */
    int local = 10;
    
    /* Static: Created once, persists */
    static int persistent = 20;
    
    local++;
    persistent++;
    
    printf("local: %d, persistent: %d\n", local, persistent);
}

int main(void) {
    lifetime_demo();  // local: 11, persistent: 21
    lifetime_demo();  // local: 11, persistent: 22
    lifetime_demo();  // local: 11, persistent: 23
    
    /* Block lifetime */
    {
        int x = 5;  // x created
        printf("x: %d\n", x);
    }  // x destroyed
    
    return 0;
}

/* Dangerous: Returning pointer to local */
int* bad_function(void) {
    int local = 42;
    return &local;  // WRONG! local destroyed after return
}

/* Safe: Returning pointer to static */
int* safe_function(void) {
    static int persistent = 42;
    return &persistent;  // OK: persistent exists for program lifetime
}

Best Practices

Effective use of scope and storage classes makes code more maintainable, testable, and less error-prone. Follow these principles to write professional C code with proper variable management.

C
/* Practice 1: Minimize global variable use */
// Bad: Everything global
int count;
int total;
int average;

void calculate(void) {
    total = count * 10;
    average = total / count;
}

// Good: Use parameters and return values
int calculate_total(int count) {
    return count * 10;
}

int calculate_average(int total, int count) {
    return total / count;
}

/* Practice 2: Use static for file-private functions/data */
// module.c:
static int internal_state = 0;  // Hidden from other files

static void internal_helper(void) {  // Not exported
    // Helper function
}

// Public API:
void public_function(void) {
    internal_helper();
}

/* Practice 3: Declare variables in smallest scope */
// Bad: Unnecessarily wide scope
int main(void) {
    int i, j, temp;
    
    // Code not using i, j, temp...
    
    for (i = 0; i < 10; i++) {
        // Use i
    }
}

// Good: Declare where used
int main(void) {
    // Other code...
    
    for (int i = 0; i < 10; i++) {  // i only visible in loop
        // Use i
    }
    
    if (condition) {
        int temp = calculate();  // temp only visible in if block
    }
}

/* Practice 4: Initialize variables */
void good_initialization(void) {
    int count = 0;           // Explicit
    static int total = 0;    // Explicit (though static auto-initializes to 0)
    int array[10] = {0};     // All elements to 0
}

/* Practice 5: Use const for immutable data */
const int MAX_SIZE = 100;  // Can't be modified

void process(const int *data, int size) {
    // data can't be modified through this pointer
}

/* Practice 6: Avoid shadowing (same name, nested scope) */
int x = 10;  // Global

void shadowing_demo(void) {
    int x = 20;  // Shadows global x (confusing!)
    printf("%d\n", x);  // Which x? (prints 20)
}

// Better: Use different names
int global_x = 10;

void clear_demo(void) {
    int local_x = 20;
    printf("global: %d, local: %d\n", global_x, local_x);
}

/* Practice 7: Document shared state */
/**
 * Module state (shared across functions)
 */
static int connection_pool[MAX_CONNECTIONS];
static int active_connections = 0;

/* Practice 8: Use extern properly in headers */
// common.h:
extern int shared_config;  // Declaration only

// common.c:
int shared_config = 42;    // Definition (one file only)

Summary & What's Next

Key Takeaways:

âœ… Scope determines where variables are visible
âœ… Local variables: block/function scope
âœ… Global variables: file scope (or program-wide with extern)
âœ… auto: Default for locals, stack-allocated, destroyed on exit
âœ… static: Persists between calls, or limits visibility to file
âœ… extern: Declares variable defined elsewhere
âœ… register: Optimization hint (rarely used)
âœ… Minimize global variables, prefer local scope

What's Next?

Let's learn about recursion and function pointers!

Next: Recursion â†’