Storage Class Specifiers in C++

Every C++ variable has a storage class and a
scope.
The storage class determines the part of the
memory where storage is allocated for an
object and how long the storage allocation
continues to exist.
It also determines the scope(visibility )which
specifies the part of the program over which
the variable name is visible i.e. the variable is
accessible by name.
Lifetime of a variable/function or program is
the time during which the variable/function or
program holds memory space.

 Automatic i.e. auto
 Register
 Static
 External i.e. extern

A storage class specifier is used to refine the declaration
of a variable, a function, and parameters.
The choice of storage class affects a variable’s storage
duration, scope, and linkage.
The storage duration of a variable is the portion of
program execution during which storage for the variable
exists.
The linkage of a variable determines whether it may be
shared by more than one file in the same program.

Scope
Block
Scope
Function
Scope
Program
Scope

In this section, a block refers to any sets of statements enclosed
in braces ({ and }). A variable declared within a block has block
scope. Thus, the variable is active and accessible from its
declaration point to the end of the block. Sometimes, block
scope is also called local scope.
For example, the variable i declared within the block of the
following main function has block scope:
int main()
{
int i; /* block scope */
.
.
.
return 0;
}
 Usually, a variable with block scope is called a local variable.

Function scope indicates that a variable is active and visible from the beginning to the end
of a function.
In C, only the goto label has function scope. For example, the goto label, start, shown in
the following code portion has function scope:
int main()
{
.
.
start: /* A goto label has function scope */
.
.
goto start; /* the goto statement */
.
.
return 0;
}
Here the label start is visible from the beginning to the end of the main() function.
Therefore, there should not be more than one label having the same name within the
main() function.

A variable is said to have program scope when it is declared
outside a function. For instance, look at the following code:
int x = 0; /* program scope */
float y = 0.0; /* program scope */
int main()
{
.
.
return 0;
}
Here the int variable x and the float variable y have program
scope.
Variables with program scope are also called global variables,
which are visible among different files. These files are the
entire source files that make up an executable program. Note
that a global variable is declared with an initializer outside a
function.

Automatic :Storage for the variable
is allocated when the surrounding
block is executed; storage is
deallocated when the block
terminates, causing the variable to
lose its value.
• auto
• register
Static : The variable has a
permanent storage location, hence it
retains its value throughout the
execution of the program.
• static
• extern

External
• The same
variable may
be shared by
several files
Internal
• The variable
is restricted
to a single
file

 The auto storage class specifier lets you
explicitly declare a variable with automatic
storage.
 The auto storage class is the default for
variables declared inside a block. A variable x
that has automatic storage is deleted when
the block in which x was declared exits.
 Until C++11, auto had the semantic of a
storage duration specifier.
 Syntax
• auto variable initializer
• auto function -> return type

 You can only apply the auto storage class
specifier to names of variables declared in a
block or to names of function parameters.
However, these names by default have
automatic storage. Therefore the storage
class specifier auto is usually redundant in a
data declaration.
 Specifies that the type of the variable that is
being declared will be automatically deduced
from its initializer. For functions, specifies that
the return type is a trailing return type.

 You can initialize any auto variable except
parameters. If you do not explicitly initialize an
automatic object, its value is indeterminate. If you
provide an initial value, the expression
representing the initial value can be any valid C or
C++ expression. The object is then set to that
initial value each time the program block that
contains the object's definition is entered.
 If automatic variables are not initialized they will
contain garbage.
 Note that if you use the goto statement to jump
into the middle of a block, automatic variables
within that block are not initialized.

 Objects with the auto storage class specifier have
automatic storage duration. Each time a block is
entered, storage for auto objects defined in that
block is made available. When the block is
exited, the objects are no longer available for use.
An object declared with no linkage specification
and without the static storage class specifier has
automatic storage duration.
 If an auto object is defined within a function that is
recursively invoked, memory is allocated for the
object at each invocation of the block.

 The word register is borrowed from the world of
computer hardware. Each computer has a certain
number of registers to hold data and perform
arithmetic or logical calculations. Because
registers are located within the CPU (central
processing unit) chip, it's much quicker to access a
register than a memory location. Therefore, storing
variables in registers may help to speed up your
program.
 You can apply this specifier to variables when you
think it's necessary to put the variables into the
computer registers.

 However, the register specifier only gives the
compiler a suggestion. In other words, a variable
specified by the register keyword is not guaranteed
to be stored in a register. The compiler can ignore
the suggestion if there is no register available, or if
some other restrictions have to apply.
 Because of the limited size and number of
registers available on most systems, few variables
can actually be put in registers. If the compiler
does not allocate a machine register for a register
object, the object is treated as having the storage
class specifier auto.

 An object having the register storage class
specifier must be defined within a block or
declared as a parameter to a function.
 You can initialize any register object except
parameters. If you do not initialize an
automatic object, its value is indeterminate. If
you provide an initial value, the expression
representing the initial value can be any valid
C or C++ expression. The object is then set to
that initial value each time the program block
that contains the object's definition is entered.

 Objects with the register storage class
specifier have automatic storage duration.
Each time a block is entered, storage for
register objects defined in that block is made
available. When the block is exited, the
objects are no longer available for use.
 If a register object is defined within a function
that is recursively invoked, memory is
allocated for the variable at each invocation of
the block.

 Loop Control Variables:
int main()
{
/* block scope with the register specifier */
register int i;
. . .
for (i=0; i<MAX_NUM; i++){
/* some statements */
}
. . .
return 0;
}
 NOTE: The declaration of ‘i’ suggests that the compiler store the
variable in a register. Because ‘i’ is intensively used in the for loop,
storing ‘i’ in a register may increase the speed of the code shown
here.

IN C LANGUAGE IN C++ LANGUAGE
 The register storage class
specifier is legal only for
variables declared in a
block. You cannot use it in
global scope data
declarations.
 A register does not have an
address. Therefore, you
cannot apply the address
operator (&) to a register
variable.
 You cannot use the register
storage class specifier when
declaring objects in
namespace scope.
 Unlike C, C++ lets you take
the address of an object with
the register storage class.
For example:
register int i;
int* b = &i; // valid in C++,
but not in C

The mutable storage class specifier is
available only in C++
It is used only on a class data member to
make it modifiable even though the
member is part of an object declared as
const.

class A
{
public:
A() : x(4), y(5) { };
mutable int x;
int y;
};
int main()
{
const A var2;
var2.x = 345;
// var2.y = 2345;
}
In this example, the compiler would not allow the assignment var2.y
= 2345 because var2 has been declared as const. The compiler will
allow the assignment var2.x = 345 because A::x has been declared
as mutable.

The ‘static’ storage class has the same visibility that of the ‘automatic’ local
variable.
It doesn’t come into existence until the first call to the function containing
it.Thereafter it remains in existence for the life of the program.
It basically instructs the compiler to keep a local variable in existence during the
lifetime of the program instead of creating and destroying it each time it comes
into and goes out of scope.
Therefore ‘static’ modifiers are used when it’s necessary to remember a value
when it is not being executed ; that is between calls to the function.
Making local variables ‘static’ allows them to maintain their values between
function calls.
The ‘static’ modifier may also be applied to global variables. When this is done,
it causes that variable's scope to be restricted to the file in which it is declared.
In C++, when static is used on a class data member, it causes only one copy of
that member to be shared by all objects of its class.

#include <iostream>
#include<conio.h>
using namespace std;
static int cost = 10; /* Global variable */
class c
{
public :
static int i=5;
void func()
{
cout<<"i is "<<i<<endl;
i--;
}
void func2()
{ cout<<“ cost is " <<cost<<endl;
cost--;
}

class d
{
public :
void disp()
{
cout<<"cost is " <<cost<<endl;
}
};
main()
{
c ob; d ob1;
while( ob.i!=0)
ob.func();
ob.func2();
cost-=5;
ob1.disp();
getch();
}

i is 5
i is 4
i is 3
i is 2
i is 1
i is 0
cost is 10
cost is 4.

Unlike local variables global variables are declared
outside of any function or class. So a global
variable is visible to all the functions in a file.
More precisely global variables are visible to only
those functions in the file that follow the variable’s
definition in listing.
Usually we want global variables to be visible to all
functions or classes in the file so we put their
definition at the beginning of the listing.

file1
#include<iostream>
#include<conio.h>
int i; // initialized to 0 by default as global
extern void write_extern(); //to be discussed little later
class c
{ public :
void disp()
{ cout<<“The value of i is “<<i<<endl;
i++;
}
};

class d
{ public :
void disp1()
}
};
main()
{ c ob; d ob1;
ob.disp();
i++;
ob1.disp1();
write_extern();
getch();
}

Output :
The value of i is 0
The value of i is 2
Note :
• Here the first thing to be noted is that variable i, declared at the
very beginning right after import ing the header files. This is done
so that i is visible to all the classes or functions under the same
file.
• i is declared though but not initialized by any value as global
variables get automatically initialized to 0 if not explicitly done.
• Lastly as said earlier if i here was specified following class c but
before class d then it would be visible in class d & main() function
but NOT in class c since global variables are visible to functions
or classes that follow the variable’s definition in listing.
Lifetime & visibility :
Global variables are automatically given the static storage class
specifier during their definition. So they exist for the life of the
program.
Memory space is set aside for them when the program begins
and continues to exist until the program ends.

The key word ‘extern’ basically extends the scope of a global
variable. ( Global variables are ‘extern’ by default.)
 It is used to give a reference of a global variable that is visible to
ALL the program files.
 When ‘extern’ precedes a variable, it cannot be initialized as all it
does is point the variable name at a storage location that has
been previously defined.
 When we have multiple files and we define a global variable or
function which will be used in other files also or say the program
is spread across two or more files, then ‘extern’ will be used to
give reference of defined variable or function. So basically
‘extern’ is used to declare a global variable or function in other
files.
 The extern modifier is most commonly used when there are two
or more files sharing the same global variables or functions .
A small demonstration is given from the previous
example to help understand the concept better :

file2
#include<iostream>
#include<conio.h>
extern int i; //..here the extern keyword is used to declare i in this
file and it refers to g.v. i declared in the previous file…
class a
{
public :
void write_extern()
}
};
Note : It is because of the ‘extern’ specifier that variable i could
be used in this file & void write_extern() in the previous
file.

Static local Global
Visibility function file
Lifetime program program
Initialized value 0 0
Purpose Same as local but
retains value
when function
terminates.
Variables used by
several classes &
functions but
inside the same
file.
Comparison between Static local and global :

Books:
1. Robert Lafore
2. Herbert Schildt
 Websites:
1. Hawaii.edu
2. Tutorialspoint.com

Storage Class Specifiers in C++

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Storage Class Specifiers in C++ (20)

Recently uploaded (20)

Storage Class Specifiers in C++