C Storage Classes

📦 C Storage Classes – Managing Variable Scope and Lifetime

In C, storage classes define the scope, visibility, and lifetime of variables. They tell the compiler where and for how long the variable should exist. There are four main storage classes in C: auto, register, static, and extern.

🔹 1. Auto Storage Class

The auto storage class is the default for local variables. It means that the variable is automatically created when the function is called and destroyed when the function exits.

📝 Example 1: Using Auto Storage Class

The auto keyword is optional, as it’s the default for local variables.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
#include <stdio.h>
int main() {
auto int num = 5; // auto is optional here
printf("Auto variable: %d\n", num);
return 0;
}
#include <stdio.h> int main() { auto int num = 5; // auto is optional here printf("Auto variable: %d\n", num); return 0; }
#include <stdio.h>

int main() {
    auto int num = 5; // auto is optional here
    printf("Auto variable: %d\n", num);
    return 0;
}
  

Try It Now

🔹 2. Register Storage Class

The register storage class suggests to the compiler to store the variable in a CPU register for faster access. It’s typically used for loop counters or variables that need quick access. Note that not all variables can be stored in a register, as it depends on the availability of CPU registers.

📝 Example 2: Using Register Storage Class

Here, we suggest storing the variable counter in a register.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
#include <stdio.h>
int main() {
register int counter;
for (counter = 1; counter <= 5; counter++) {
printf("Counter: %d\n", counter);
}
return 0;
}
#include <stdio.h> int main() { register int counter; for (counter = 1; counter <= 5; counter++) { printf("Counter: %d\n", counter); } return 0; }
#include <stdio.h>

int main() {
    register int counter;
    for (counter = 1; counter <= 5; counter++) {
        printf("Counter: %d\n", counter);
    }
    return 0;
}
  

Try It Now

🔹 3. Static Storage Class

The static storage class retains the variable's value between function calls. This is useful when you want to keep a variable’s state even after the function has finished executing. It can be used for both global and local variables.

📝 Example 3: Using Static Storage Class

In this example, the static variable retains its value between function calls.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
#include <stdio.h>
void counterFunction() {
static int counter = 0; // Retains value between calls
counter++;
printf("Counter: %d\n", counter);
}
int main() {
counterFunction(); // Counter will be 1
counterFunction(); // Counter will be 2
counterFunction(); // Counter will be 3
return 0;
}
#include <stdio.h> void counterFunction() { static int counter = 0; // Retains value between calls counter++; printf("Counter: %d\n", counter); } int main() { counterFunction(); // Counter will be 1 counterFunction(); // Counter will be 2 counterFunction(); // Counter will be 3 return 0; }
#include <stdio.h>

void counterFunction() {
    static int counter = 0; // Retains value between calls
    counter++;
    printf("Counter: %d\n", counter);
}

int main() {
    counterFunction(); // Counter will be 1
    counterFunction(); // Counter will be 2
    counterFunction(); // Counter will be 3
    return 0;
}
  

Try It Now

🔹 4. Extern Storage Class

The extern storage class is used to declare a global variable that is defined in another file. It allows sharing variables between different files in a program.

📝 Example 4: Using Extern Storage Class

In this example, we declare an extern variable in one file and define it in another file.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
/* file1.c */
#include <stdio.h>
extern int num; // Declaration of extern variable
void display() {
printf("Num is: %d\n", num); // Accessing extern variable
}
/* file2.c */
#include <stdio.h>
int num = 10; // Definition of extern variable
int main() {
display(); // Access extern variable from file1.c
return 0;
}
/* file1.c */ #include <stdio.h> extern int num; // Declaration of extern variable void display() { printf("Num is: %d\n", num); // Accessing extern variable } /* file2.c */ #include <stdio.h> int num = 10; // Definition of extern variable int main() { display(); // Access extern variable from file1.c return 0; }
/* file1.c */
#include <stdio.h>

extern int num; // Declaration of extern variable

void display() {
    printf("Num is: %d\n", num); // Accessing extern variable
}

/* file2.c */
#include <stdio.h>

int num = 10; // Definition of extern variable

int main() {
    display(); // Access extern variable from file1.c
    return 0;
}
  

Try It Now

🎯 Summary of Storage Classes

  • auto: Default for local variables, scope limited to the function.
  • register: Suggests storing variable in CPU registers for faster access.
  • static: Retains the variable's value between function calls, scope limited to the function.
  • extern: Allows access to global variables defined outside the current file.

💡 Practice Challenge

Experiment with each storage class in your programs to understand their behaviors. Try using static to keep track of counters across function calls and extern to share variables between files!