Storage Classes

Every C variable has a storage class and a scope. The storage class determines the part of memory where storage is allocated for an object and how long the storage allocation continues to exist. It also determines the scope which specifies the part of the program over which a variable name is visible, i.e. the variable is accessible by name. The are four storage classes in C are automatic, register, external, and static.

automatic

They are declared at the start of a block. Memory is allocated automatically upon entry to a block and freed automatically upon exit from the block. The scope of automatic variables is local to the block in which they are declared, including any blocks nested within that block. For these reasons, they are also called local variables. No block outside the defining block may have direct access to automatic variables, i.e. by name. Of course, they may be accessed indirectly by other blocks and/or functions using pointers.

Automatic variables may be specified upon declaration to be of storage class auto. However, it is not required; by default, storage class within a block is auto. Automatic variables declared with initializers are initialized each time the block in which they are declared is entered.

register

Register variables are a special case of automatic variables. Automatic variables are allocated storage in the memory of the computer; however, for most computers, accessing data in memory is considerably slower than processing in the CPU. These computers often have small amounts of storage within the CPU itself where data can be stored and accessed quickly. These storage cells are called registers.

Normally, the compiler determines what data is to be stored in the registers of the CPU at what times. However, the C language provides the storage class register so that the programmer can "suggest" to the compiler that particular automatic variables should be allocated to CPU registers, if possible. Thus, register variables provide a certain control over efficiency of program execution. Variables which are used repeatedly or whose access times are critical, may be declared to be of storage class register.

Global variables

However, in some applications it may be useful to have data which is accessible from within any block and/or which remains in existence for the entire execution of the program. Such variables are called global variables, and the C language provides storage classes which can meet these requirements; namely, the external and static classes.

External

External variables may be declared outside any function block in a source code file the same way any other variable is declared; by specifying its type and name. No storage class specifier is used - the position of the declaration within the file indicates external storage class. Memory for such variables is allocated when the program begins execution, and remains allocated until the program terminates. For most C implementations, every byte of memory allocated for an external variable is initialized to zero.

Static

Static storage class is declared with the keyword static as the class specifier when the variable is defined. These variables are automatically initialized to zero upon memory allocation just as external variables are. Static storage class can be specified for automatic as well as external variables.

Static automatic variables continue to exist even after the block in which they are defined terminates. Thus, the value of a static variable in a function is retained between repeated function calls to the same function. The scope of static automatic variables is identical to that of automatic variables, i.e. it is local to the block in which it is defined; however, the storage allocated becomes permanent for the duration of the program. Static variables may be initialized in their declarations; however, the initializers must be constant expressions, and initialization is done only once at compile time when memory is allocated for the static variable.

#include <stdio.h>

// Global variable (extern storage class)
int global_var = 10;

void function_scope() {
  // Static variable
  static int static_var = 20;
  static_var++; // Preserves value across function calls

  // Automatic variable (auto storage class)
  int auto_var = 30;

  printf("Inside function:\n");
  printf("  global_var: %d (accessible anywhere)\n", global_var);
  printf("  static_var: %d (preserves value across function calls)\n", static_var);
  printf("  auto_var: %d (local to function, disappears after call)\n", auto_var);
}

int main() {
  // Automatic variable with same name as function-local one
  int auto_var = 40;

  printf("In main:\n");
  printf("  global_var: %d (shared across file)\n", global_var);
  function_scope(); // Call the function
  printf("  auto_var (after function call): %d (reinitialized on each call)\n", auto_var);

  // Register variable (register storage class, compiler may ignore)
  register int reg_var = 50;
  printf("  reg_var: %d (potentially stored in CPU register for faster access)\n", reg_var);

  return 0;
}

• Global variable (global_var): Declared outside any function, accessible throughout the program.

• Static variable (static_var): Declared with static inside a function, retains its value across function calls.

• Automatic variable (auto_var): Declared in function scope, disappears after function returns.

• Register variable (reg_var): Declared with register, compiler may store it in a CPU register for faster access (optional, compiler can ignore).