Storage Class in C++

A storage class is a concept in programming that defines the properties and behavior of variables and functions in terms of their lifetime, scope, visibility, and storage location. It specifies how and where these entities are stored in memory, how long they remain accessible, and the extent of their visibility within a program.

In most programming languages, including C++, storage classes allow programmers to control the behavior of variables and functions, enabling efficient memory management and controlling the visibility of entities across different scopes and files.

auto

The auto storage class is used to declare variables with automatic storage duration. It is the default storage class for local variables. The auto keyword is optional in C++ since local variables are automatically considered as having automatic storage. Here's the syntax:

auto variable = value; // 'auto' keyword is optional

Example

void foo() {
    auto x = 10; // 'auto' keyword is optional here
}

In this example, the variable x is declared with automatic storage duration, and its type is automatically deduced based on the assigned value (int in this case).

register

The register storage class is used to suggest that a local variable should be stored in a CPU register for faster access. However, the register keyword is merely a hint to the compiler, and it may choose to ignore it. Here's the syntax:

register data_type variable;
Example 
void foo() {
    register int x = 5; // Suggests the compiler to store 'x' in a register
}

In this example, the variable x is declared with the register storage class, hinting to the compiler that it should be stored in a register for faster access.

static

The static storage class has multiple uses. When used with local variables, it changes the storage duration of the variable to static, meaning it retains its value between different function calls. When used with global variables or functions, it restricts their visibility to the file where they are declared. Here's the syntax:

static data_type variable; // For local variables or global variables within a file
static return_type function_name(parameters); // For static functions
Example 
void foo() {
    static int counter = 0; // 'counter' retains its value across function calls
    counter++;
    cout << "Counter: " << counter << endl;
}
static int globalVar = 10; // 'globalVar' is only visible within this file
static void utilityFunc() {
    // Code for the utility function
}

In the first example, the counter variable is declared with the static storage class. It retains its value across different function calls, incrementing each time the function is invoked.

In the second example, the globalVar variable is declared as a global variable with the static storage class, making it only visible within the file it is declared in. The utilityFunc function is also declared as a static function, limiting its visibility to the same file.

extern

The extern storage class is used to declare a global variable or function that is defined in another file. It is used to provide visibility of a variable or function across multiple files in a program. Here's the syntax:

extern data_type variable; // For global variables or functions declared in another file
Example 
// File1.cpp
extern int sharedVar; // Declaration of a shared variable
// File2.cpp
int sharedVar = 5; // Definition of the shared variable

In this example, the sharedVar variable is declared in File1.cpp using the extern keyword, indicating that it is defined in another file. The actual definition of the variable is provided in File2.cpp.