Storage Classes in C Programming – Complete Guide for Beginners

Introduction to Storage Classes in C

In this tutorial topic, we will learn in detail about the storage class in C, its types, and how its properties affect the output of the program along with some programming examples.

C programming puts a lot of importance on the use of variables in all programs. Every variable we declare in a C program has a scope and lifetime. Each variable in C has two properties: data type and storage class. The data type refers to the data of the variable, and the storage class determines the scope, visibility, and lifetime of the variable.

A storage class in C is used to define the lifetime, visibility, memory location, and initial value of a variable.

Characteristics of Storage Classes

A storage class in C defines the following characteristics of a variable:

• a. Scope (Visibility): Indicates where the variable is accessible in the program and where it is not. The scope of a variable is determined only at compile time without creating any function call stack that occurs at runtime.
• b. Lifetime: How long a variable stays in the appropriate location in system memory. It is the time between when memory is allocated to hold the variable and when it is freed. Once a variable goes out of scope, its lifetime expires.
• c. Memory Allocation: Where functions or variables are stored in memory (CPU or RAM registers).
• d. Initial Value: The default value assigned to the variable when it is declared.

Types of Storage Classes in C

Storage classes or memory classes in C language are declared in a program or block with memory class specifiers:

• auto - Automatic storage class
• register - Register storage class
• static - Static storage class
• extern - External storage class

There is another storage class specifier, "typedef", used syntactically, which does not reserve memory. Specifiers instruct the compiler to store variables.

1. Auto Storage Class (Automatic)

This is the default storage class that holds the values or objects for all the variables that are displayed in the function or block. If a storage class is not specified, every variable defined in a function or block will default to the automatic storage class.

Therefore, the auto keyword is rarely used when writing C programs. Functions or block variables contained in the auto storage class are declared using the auto specifier. Variables in C are local to the block they are defined in and are discarded outside the block.

C Program Demonstrating Auto Storage Class

#include <stdio.h>

int main() {
    auto int v = 11;
    {
        auto int v = 22;
        {
            auto int v = 33;
            printf("%d ", v);
        }
        printf("%d ", v);
    }
    printf("%d", v);
    return 0;
}

Output:

33 22 11

Explanation:

1. The variable v is declared three times in different blocks.
2. The variable v with the same name is defined three times in different blocks.
3. The program will compile and run successfully without any error.
4. The printf() function in the innermost block prints 33, and variable v inside this block is destroyed after the block ends.
5. This is followed by another block which prints 22, which is followed by a block which prints 11.
6. Automatic variables are initialized correctly; otherwise, you will get undefined values because the compiler does not assign an initial value to them.

2. Register Storage Class

The register storage class is a required specifier that tells the compiler to store the object in a machine register. Variables defined as registers are allocated among CPU registers according to the size of memory remaining in the CPU.

When you want to store local variables in a function or block in CPU registers instead of RAM to get quick access to these variables, you can use the register storage class. The access time for register variables is faster.

C Program Demonstrating Register Keyword

#include <stdio.h>

int main() {
    register int a;  // Declaring 'a' as a register variable
    int b;
    
    a = 100;
    b = 200;
    
    printf("Value of a: %d\n", a);
    printf("Value of b: %d\n", b);
    
    return 0;
}

Output:

Value of a: 100
Value of b: 200

Explanation:

In the above example, we have defined a as a register variable. On the other hand, whether it is actually stored in a CPU register depends on the behavior of the compiler. The main thing you need to consider is that the register will not match the variables whose addresses are selected using the & operator, because it is not easy to directly deal with the register. Therefore, trying to apply registry changes results in a compilation error.

3. Static Storage Class

The static storage class defines a variable with a fixed lifetime. This means the variable is allocated in memory when the program starts and is deleted only after the program terminates. This means that the variable retains its value between function calls.

C Program Demonstrating Static Storage Class

#include <stdio.h>

int statfunc() {
    static int tot = 40;
    tot++;
    return tot;
}

int main() {
    printf("total = %d \n", statfunc());
    printf("total = %d \n", statfunc());
    return 0;
}

Output:

total = 41
total = 42

Explanation:

1. The statfunc() function has a variable called tot, initially set to 40.
2. The static keyword is used to create a static variable, meaning that the variable's value will be conserved or preserved between function calls.
3. The statfunc function increments the value of tot by 1 and then returns the new value.
4. When statfunc() is called, it will always return the next value in the sequence (41, 42).
5. In the main function, statfunc() is called twice, and the return value is printed using the printf function.

4. Extern Storage Class

The extern storage class is used when we have functions or global variables shared between two or more files. The word extern is used to define a global variable or function in another file to refer to a variable or function that is already defined in the original file.

Variables defined with the extern keyword are called global variables. These variables are available to access during the entire program. Note that an extern variable cannot be initialized because it is already defined in the original base file.

Example: Extern Storage Class

File1: main.c

#include <stdio.h>

extern int xt;

int main() {
    printf("The value of the external integer xt is = %d\n", xt);
    return 0;
}

File2: original.c

#include <stdio.h>

int xt = 48;

Output:

The value of the external integer xt is = 48

Summary of Storage Classes

#include <stdio.h>

void autoCounter() {
    int count = 0;  // auto variable - resets each time
    count++;
    printf("Auto: %d\n", count);
}

void staticCounter() {
    static int count = 0;  // static variable - retains value
    count++;
    printf("Static: %d\n", count);
}

int main() {
    printf("Auto Counter (resets each call):\n");
    autoCounter();
    autoCounter();
    autoCounter();
    
    printf("\nStatic Counter (retains value):\n");
    staticCounter();
    staticCounter();
    staticCounter();
    
    return 0;
}

/* Output:
Auto Counter (resets each call):
Auto: 1
Auto: 1
Auto: 1

Static Counter (retains value):
Static: 1
Static: 2
Static: 3
*/

Frequently Asked Questions About Storage Classes in C

Previous Topic: -->> realloc() in C   ||   Next topic: -->> Graphics in C