Article by: Manish Methani
Last Updated: November 3, 2021 at 2:04pm IST
In this tutorial, we'll cover the basics of storage classes in C programming, including their types, scope, and usage. We'll also provide some code examples to help you better understand how they work.
Storage classes in C programming are used to define the scope, visibility, and lifetime of variables and functions. There are four types of storage classes in C programming: automatic, static, register, and extern.
The automatic storage class is the default storage class for variables declared inside a function. These variables are created when the function is called and destroyed when the function exits. They are not visible to other functions and cannot be accessed outside the function where they are declared.
Here's an example of how to declare a variable using the automatic storage class:
void myFunction() {
int x; // automatic storage class
}
The static storage class is used to declare variables that retain their values even after the function exits. These variables are initialized only once, and their value is preserved between function calls. They have global scope within the file where they are declared and can be accessed from any function within that file.
Here's an example of how to declare a variable using the static storage class:
void myFunction() {
static int x; // static storage class
}
The register storage class is used to declare variables that should be stored in a processor register instead of memory. These variables are usually used for frequently accessed data to improve program efficiency. However, it is up to the compiler to decide whether or not to store the variable in a register.
Here's an example of how to declare a variable using the register storage class:
void myFunction() {
register int x; // register storage class
}
The extern storage class is used to declare variables and functions that are defined in other files or modules. When a variable or function is declared with the extern keyword, it tells the compiler that the definition of the variable or function will be provided later in another file or module.
In other words, the extern storage class is used to establish the global scope of a variable or function, allowing it to be used in multiple files or modules.
When you declare a variable or function with the extern keyword, you are telling the compiler that the definition of the variable or function is not in the current file or module. Instead, the definition is in another file or module, and the compiler needs to look for it at link time.
Here's an example of how to declare a variable using the extern storage class:
// File 1
extern int x; // declare variable x in another file or module
void myFunction() {
// use variable x
}
// File 2
int x; // define variable x in this file or module
int main() {
// initialize variable x
x = 10;
// call function that uses variable x
myFunction();
}
In this example, we have two files: File 1 and File 2. File 1 declares the variable x using the extern keyword, indicating that its definition is in another file or module. File 2 defines the variable x and initializes it to a value of 10. When File 1's function myFunction is called, it uses the variable x without having to know its definition because it was declared with the extern keyword.
In this tutorial, we covered the basics of storage classes in C programming. We explained the different types of storage classes and how they are used to define the scope, visibility, and lifetime of variables and functions. We also provided some code examples to help you better understand how they work. By understanding the different storage classes, you can write more efficient and organized code.
