Storage Classes in C

by

In the C programming language, storage classes define the scope, lifetime, and visibility of variables or functions. C provides four storage classes: auto, register, static, and extern. Here’s a brief explanation of each storage class:

  1. auto: This is the default storage class for local variables declared within a block or function. Variables declared as “auto” are created when the block or function is entered and are destroyed when the block or function is exited. This storage class is rarely used explicitly since it’s the default.
  2. register: The “register” storage class is used to suggest the compiler to store the variable in a register instead of memory. However, it’s up to the compiler to decide whether to honor the request or not. Register variables are generally faster to access but have limitations on their size and the number of available registers.
  3. static: Variables declared as “static” have a lifetime that spans the entire program execution, but their visibility is limited to the block or function in which they are declared. Static variables retain their values between different function calls, making them useful for maintaining state across function invocations. When used outside of a function, static variables have file scope and are not accessible from other source files.
  4. extern: The “extern” storage class is used to declare a global variable or function that is defined in another source file. When a variable or function is declared as “extern,” it means that its definition is located in another file, and the linker will resolve its references at the linking stage.

Here’s an example that demonstrates the usage of these storage classes:

#include <stdio.h>

int globalVariable = 10;  // Global variable

void function()
{
    auto int localVar = 20;     // Automatic variable
    static int staticVar = 30; // Static variable

    printf("Local variable: %d\n", localVar);
    printf("Static variable: %d\n", staticVar);

    localVar++;
    staticVar++;
    globalVariable++;
}

int main()
{
    extern int globalVariable; // External variable

    function();
    function();

    printf("Global variable: %d\n", globalVariable);

    return 0;
}

In this example, the auto storage class is used implicitly for the localVar variable, the static storage class is used for the staticVar variable, the extern storage class is used for the globalVariable variable, and the register storage class is not used.

Automatic:

In the C programming language, the “automatic” storage class is used to declare local variables within a block or function. It is the default storage class for variables declared without explicitly specifying any storage class.

Here are some key points about the “automatic” storage class:

  • Variables declared as “automatic” are created when the block or function is entered and are destroyed when the block or function is exited. This means that their lifetime is limited to the scope in which they are defined.
  • The values of automatic variables are not retained between different invocations of the block or function. Each time the block or function is entered, the variable is initialized.
  • The “automatic” storage class is rarely used explicitly since it is the default. If you declare a variable without specifying any storage class, it is automatically considered as an automatic variable.

Here’s an example demonstrating the usage of the automatic storage class:

#include <stdio.h>

void function()
{
    auto int localVar = 10;  // Automatic variable

    printf("Local variable: %d\n", localVar);

    localVar++;
}

int main()
{
    function();
    function();

    return 0;
}

In this example, the localVar variable is declared as an automatic variable within the function block. Each time the function is called, a new instance of the localVar variable is created with an initial value of 10. The value of localVar is incremented within the function, but since it is an automatic variable, its value is not retained between different invocations of the function.

Static:

In the C programming language, the “static” storage class is used to declare variables or functions with static storage duration. When applied to variables, the “static” storage class modifies the lifetime, visibility, and initialization behavior of the variables. Here are some key points about the “static” storage class:

  1. Lifetime: Variables declared as “static” have a lifetime that spans the entire execution of the program. They are created when the program starts and persist until the program terminates. This is in contrast to automatic variables, which are created and destroyed each time the associated block or function is entered and exited, respectively.
  2. Visibility: When “static” is applied to variables within a block or function, their visibility is limited to that block or function. They cannot be accessed directly from other blocks or functions in the same file.
  3. Initialization: By default, static variables are initialized to zero if no explicit initializer is provided. The initialization occurs only once, during the first encounter with the declaration. Subsequent entries into the block or function will not reinitialize the static variables.
  4. Persistence of value: Static variables retain their values between different invocations of the associated block or function. When the block or function is re-entered, the static variables maintain the values they held from the previous invocation. This feature makes static variables useful for maintaining state across function calls.
  5. File scope: When “static” is applied to variables outside of any block or function (at the global scope), it changes the visibility of the variable to be limited to the current source file. Such static variables are not accessible from other source files linked together.

Here’s an example demonstrating the usage of the “static” storage class:

#include <stdio.h>

void function()
{
    static int staticVar = 10;  // Static variable

    printf("Static variable: %d\n", staticVar);

    staticVar++;
}

int main()
{
    function();  // Prints "Static variable: 10"
    function();  // Prints "Static variable: 11"

    return 0;
}

In this example, the staticVar variable is declared as a static variable within the function block. The variable is initialized to 10 during the first invocation of function, and its value is incremented by 1 in each subsequent invocation. The value of staticVar is retained between different invocations of function, allowing it to maintain state across function calls.

Register:

In the C programming language, the “register” storage class is used to suggest to the compiler that a variable should be stored in a CPU register for faster access. It is an optimization hint provided by the programmer, indicating that a particular variable will be used frequently and would benefit from being stored in a register.

Here are some key points about the “register” storage class:

  1. Usage: The “register” storage class is used to declare variables that are intended to be stored in registers. It is typically used for variables that are accessed frequently within a block or function.
  2. Compiler optimization: The use of the “register” storage class does not guarantee that a variable will be stored in a register. The decision to allocate a register is made by the compiler, which takes into consideration factors such as the availability of registers, the size of the variable, and the frequency of its usage. The “register” keyword serves as a hint to the compiler, but the final decision is implementation-dependent.
  3. Limitations: Variables declared as “register” have certain limitations. They cannot have their address taken using the “&” operator since they are not stored in memory. Additionally, the size of a “register” variable is typically limited to the size of a CPU register.
  4. Impact on performance: Storing variables in registers can lead to faster access times compared to memory-based variables. However, the actual performance improvement may vary depending on the specific hardware and optimization performed by the compiler.

Here’s an example demonstrating the usage of the “register” storage class:

#include <stdio.h>

int main()
{
    register int count;  // Register variable
    int sum = 0;

    for (count = 1; count <= 100000; count++)
    {
        sum += count;
    }

    printf("Sum: %d\n", sum);

    return 0;
}

In this example, the variable count is declared as a register variable within the main function. The compiler may choose to store the count variable in a CPU register for faster access within the loop. However, the decision to allocate a register ultimately rests with the compiler. The use of the “register” keyword serves as an optimization hint to the compiler.

External:

In the C programming language, the “extern” storage class specifier is used to declare a global variable or function that is defined in another source file. It is used to provide a reference to an entity (variable or function) that is defined in a different file or module, allowing the program to access that entity from the current file.

Here are some key points about the “extern” storage class:

  1. Declaration: When a variable or function is declared as “extern,” it means that its definition is located in another source file. The “extern” keyword is used to declare the entity without allocating memory for it. It serves as a way to inform the compiler about the existence of the entity.
  2. Linkage: The “extern” storage class specifier affects the linkage of the declared entity. By default, variables and functions declared at the global scope have external linkage, meaning they can be accessed from other files. The “extern” keyword explicitly specifies that the entity has external linkage.
  3. Multiple file usage: When a variable or function is defined in one file (referred to as the definition file) and declared as “extern” in another file (referred to as the referencing file), the referencing file can access and use the entity from the definition file.
  4. Linking: During the linking phase, the linker resolves the references to “extern” entities by locating their actual definitions in the corresponding source files. This ensures that the program can correctly access and use the entities across different files.

Here’s an example demonstrating the usage of the “extern” storage class:

File: math.h

extern int add(int a, int b);  // Function declaration

File: math.c

int add(int a, int b)
{
    return a + b;
}

File: main.c

#include <stdio.h>
#include "math.h"  // Including the header file

extern int globalVariable;  // External variable declaration

int main()
{
    int result = add(3, 5);  // Calling the external function

    printf("Result: %d\n", result);
    printf("Global variable: %d\n", globalVariable);

    return 0;
}

In this example, there are three files: math.h, math.c, and main.c. The math.h header file declares the add function using the “extern” keyword. The math.c file defines the add function. The main.c file includes the math.h header and uses the add function by calling it. The extern keyword is also used to declare the globalVariable variable, which is defined in another file. The linker resolves the references to the add function and globalVariable during the linking phase, allowing the program to access and use them correctly.