Hi everyone, inside this article we will see about C++ Storage Class.
In C++, storage classes define the scope (visibility) and lifetime of variables and functions. They determine how variables are stored in memory and how long they remain accessible.
The following are the four main storage classes in C++:
- Auto
- Register
- Static
- Extern
Here is a comparison of the four C++ storage classes:
Storage Class | Scope | Lifetime | Initialization | Memory Location |
---|---|---|---|---|
auto | Local | Automatic destruction at end of block | Automatic | Stack |
register | Local | Automatic destruction at end of block | Automatic | Register (if available) or Stack |
static | Local | Persistent | Automatic, but only initialized once | Data segment |
extern | Global | Persistent | None (must be defined elsewhere) | Data segment |
‘Scope‘ refers to the visibility of the variable, and determines where the variable can be accessed from.
‘Lifetime‘ refers to how long the variable remains in memory and accessible.
‘Initialization‘ refers to whether the variable is automatically initialized when it is declared or if it must be explicitly initialized elsewhere.
‘Memory Location‘ refers to where the variable is stored in memory, and can affect the speed of access and the size of the program.

C++ Auto Storage Class
The “auto” storage class in C++ is the default storage class for local variables, declared within a function. An automatic storage class variable is created on the stack and is automatically destroyed when the block in which it is declared ends.
Syntax
auto x = value;
Here’s an example:
#include <iostream> using namespace std; void print_value(int value) { auto x = value; cout << "The value of x is: " << x << endl; } int main() { print_value(10); return 0; }
Output
The value of x is: 10
In this example, the variable x
is declared as an auto
storage class variable within the print_value
function. The variable x
is created on the stack when the function is called, and is destroyed automatically when the function ends. The value of x
is set to the argument passed to the function (value
), and is then used to print a message to the console.
C++ Register Storage Class
The “register” storage class in C++ is used to declare variables that should be stored in a register, instead of in memory. This allows for faster access to the variable, as the register is a high-speed memory area located on the computer’s CPU.
However, the number of registers is limited, so it’s not always possible to store a variable in a register. In such cases, the compiler will store the variable in memory instead.
Syntax
register int x = 10;
Here’s an example:
#include <iostream> using namespace std; int main() { register int x = 10; cout << "The value of x is: " << x << endl; return 0; }
Output
The value of x is: 10
In this example, the variable x
is declared as a register
storage class variable. This means that the compiler will try to store the variable in a register, if possible. The value of x
is set to 10
, and is then used to print a message to the console.
C++ Static Storage Class
The “static” storage class in C++ is used to declare variables that have a local scope, but retain their value between function calls.
A static storage class variable is only initialized once, when the program starts. The variable remains in memory for the entire lifetime of the program, and retains its value between function calls.
Syntax
static int x = 0;
Here’s an example:
#include <iostream> using namespace std; void increment_value() { static int x = 0; x++; cout << "The value of x is: " << x << endl; } int main() { increment_value(); increment_value(); increment_value(); return 0; }
Output
The value of x is: 1
The value of x is: 2
The value of x is: 3
In this example, the increment_value
function declares a static storage class variable x
. The first time the function is called, the variable x
is initialized to 0
. The value of x
is then incremented each time the function is called, and is used to print a message to the console.
Because x
is a static storage class variable, its value is retained between function calls, so each time the function is called, the value of x
is one greater than it was the last time the function was called. This allows us to keep track of the number of times the function has been called, even though the variable x
has a local scope.
C++ External Storage Class
The “extern” storage class in C++ is used to declare variables that have a global scope, but are defined in another source file. The extern
storage class is used to provide a reference to a global variable that is defined in another source file.
Syntax
extern int x;
Here’s an example:
File main.cpp
:
#include <iostream> using namespace std; extern int x; int main() { cout << "The value of x is: " << x << endl; return 0; }
File x.cpp
:
int x = 10;
In this example, the variable x
is defined in the x.cpp
file as a global variable, with a value of 10
. The main.cpp
file uses the extern
storage class to declare a reference to the variable x
, which is defined in the x.cpp
file. The value of x
is then used to print a message to the console.
It’s important to note that the use of the extern
storage class does not actually define the variable, it only provides a reference to a variable that has already been defined. The variable must be defined in exactly one source file, and can be referenced from any number of other source files using the extern
storage class.
We hope this article helped you to understand about C++ Storage Class in a very detailed way.
Online Web Tutor invites you to try Skillshike! Learn CakePHP, Laravel, CodeIgniter, Node Js, MySQL, Authentication, RESTful Web Services, etc into a depth level. Master the Coding Skills to Become an Expert in PHP Web Development. So, Search your favourite course and enroll now.
If you liked this article, then please subscribe to our YouTube Channel for PHP & it’s framework, WordPress, Node Js video tutorials. You can also find us on Twitter and Facebook.