Skip to main content

Storage Classes

This document covers storage classes in C.

Storage classes in C define the scope (visibility), lifetime, and memory location of variables. Understanding storage classes is essential for writing efficient and modular C programs.

Scope of a variable determines where it can be accessed in a program. A variable can have block scope (local variables), file scope (global/static variables), or external linkage (extern variables used across multiple files).

In this section, we will cover:

  • Types of Storage Classes (auto, extern, static, register).
  • Scope and lifetime of variables.
  • Practical use cases of storage classes.

Types of Storage Classes in C

Storage ClassScopeLifetimeMemory LocationDefault Initial Value
autoLocalBlock executionStackGarbage (Undefined)
externGlobalEntire programGlobal memoryZero (if uninitialized)
static (local)LocalProgram lifetimeGlobal memoryZero (if uninitialized)
static (global)File scopeProgram lifetimeGlobal memoryZero (if uninitialized)
registerLocalBlock executionCPU registers (if available)Garbage (Undefined)

The auto Storage Class (Default for Local Variables)

The auto storage class is the default for local variables.

Example of auto Variables

#include <stdio.h>
void function() {
auto int x = 10; // Default behavior (same as `int x = 10;`)
printf("x = %d\n", x);
}
int main() {
function();
return 0;
}
info

auto variables exist only inside the block they are defined in. They are stored in the stack memory. Their value is lost once the function exits.

The extern Storage Class (Global Variable Access)

The extern storage class extends the visibility of global variables across multiple files.

Example of extern Variables

File 1: main.c

#include <stdio.h>
extern int globalVar; // Declared but not defined
int main() {
printf("Global variable: %d\n", globalVar);
return 0;
}

File 2: global.c

#include <stdio.h>
int globalVar = 100; // Defined here
info

extern does not allocate memory, it only declares an external variable. Used to share global variables across multiple files. The actual definition must be in another file.

The static Storage Class (Preserving Values Across Calls)

Static Local Variables (Persistent Between Function Calls)

#include <stdio.h>
void counter() {
static int count = 0; // Retains its value between function calls
count++;
printf("Counter: %d\n", count);
}
int main() {
counter();
counter();
counter();
return 0;
}
info
  • A static local variable keeps its value between function calls.
  • Stored in global memory instead of the stack.

Static Global Variables (File Scope Only)

static int globalStatic = 100;  // Accessible only in this file
info
  • A static global variable cannot be accessed outside its file.
  • Prevents namespace conflicts in large programs.

The register Storage Class (Optimized for Speed)

Example of register Variables

#include <stdio.h>
int main() {
register int i = 5; // Hints compiler to store in a CPU register
printf("i = %d\n", i);
return 0;
}
info
  • register variables are stored in CPU registers (if available).
  • Useful for loop counters and frequently used variables.
  • Cannot take the address (&i is invalid).

Common Pitfalls and Best Practices

Using extern Without a Definition

Incorrect:

extern int value;  // No definition exists
printf("%d", value); // Undefined behavior!

Solution:

Ensure an actual definition exists in another file.

Misusing static for Memory Optimization

Incorrect:

Declaring large arrays as static in a recursive function can lead to high memory usage.

Solution:

Use dynamic memory (malloc) if needed.

Overusing register Variables

Incorrect:

Using register for large variables (e.g., arrays) can be inefficient.

Solution:

Only use register for small, frequently accessed variables.