What is storage class

What is Storage Class?
Storage class defined for a variable determines the accessibility and longevity of the
variable. The accessibility of the variable relates to the portion of the program that
has access to the variable. The longevity of the variable refers to the length of time
the variable exists within the program.

Types of Storage Class Variables in C++:
•
Automatic
•
External
•
Static
•
Register
Automatic:
Variables defined within the function body are called automatic variables. Auto is the
keyword used to declare automatic variables. By default and without the use of a
keyword, the variables defined inside a function are automatic variables.
For instance:

void exforsys( )
{
auto int x;
auto float y;
………
…………
}

is same as

void exforsys( )
{
int x;
float y;
………
…………
}

//Automatic Variables

In the above function, the variable x and y are created only when the function
exforsys( ) is called. An automatic variable is created only when the function is
called. When the function exforsys( ) is called, the variable x and y is allocated
memory automatically. When the function exforsys( ) is finished and exits the control
transfers to the calling program, the memory allocated for x and y is automatically

destroyed. The term automatic variable is used to define the process of memory
being allocated and automatically destroyed when a function is called and returned.
The scope of the automatic variables is only within the function block within which it
is defined. Automatic variable are also called local variables.

External:
External variables are also called global variables. External variables are defined
outside any function, memory is set aside once it has been declared and remains
until the end of the program. These variables are accessible by any function. This is
mainly utilized when a programmer wants to make use of a variable and access the
variable among different function calls.
Static:
The static automatic variables, as with local variables, are accessible only within the
function in which it is defined. Static automatic variables exist until the program ends
in the same manner as external variables. In order to maintain value between
function calls, the static variable takes its presence.
For example:

#include <iostream.h>
int exforsys(int);
void main( )
{
int in,out;
while(in!=0)
{
cout<<”Enter input value:”;
cin>>in;
out=exforsys(in);
cout<”nResult:”<<out;
}
cout<”n End of Program”<<out;
}
int exforsys(int x)
{
static int a=0;
static int b=0;
a++;
b=b+x;
return(b/a);
}

In the above program, the static variables a and b are initialized only once in the
beginning of the program. Then the value of the variables is maintained between
function calls.

When the program begins, the value of static variable a and b is initialized to zero.
The value of the input in is 5 (which is not equal to zero) and is then passed to the
function in variable x. The variable a is incremented thus making a as equal to 1.
Variable b becomes equal to 5 and thus, the return of value from function exforsys( )
for the first time is 5, which is printed in the called function.

The second time the value of the input in is 7 (which is not equal to zero) and is
passed to the function in variable x. The variable a (which is declared as static) has
the previous value of 1. This is incremented and the value of a is equal to 2. The
value of b is maintained from the previous statement as 5 and new value of b now is
b=5+7 = 12 and thus, the return value from the function is 12/2=6 which is printed
in the called function.

Storage Classes.
C has a concept of 'Storage classes' which are used to define the scope (visibility) and life
time of variables and/or functions.
So what Storage Classes are available?
auto register static extern typedef

Auto - storage class
Auto is the default storage class for local variables.
{
int Count;
auto int Month;
}
The example above defines two variables with the same storage class. auto can only be
used within functions, i.e. local variables.
Register - Storage Class
Register is used to define local variables that should be stored in a register instead of
RAM. This means that the variable has a maximum size equal to the register size (usually
one word) and cant have the unary '&' operator applied to it (as it does not have a
memory location).
{
register int Miles;
}

Register should only be used for variables that require quick access - such as counters. It
should also be noted that defining 'register' goes not mean that the variable will be stored
in a register. It means that it MIGHT be stored in a register - depending on hardware and
implementation restrictions.
Static - Storage Class
Static is the default storage class for global variables. The two variables below (count and
road) both have a static storage class.
static int Count;
int Road;
main()
{
printf("%dn", Count);
printf("%dn", Road);
}
'Static' can also be defined within a function. If this is done, the variable is initialized at
compilation time and retains its value between calls. Because it is initialsed at
compilation time, the initialization value must be a constant. This is serious stuff - tread
with care.
void Func(void)
{
static Count=1;
}
Here is an example
There is one very important use for 'static'. Consider this bit of code.
char *Func(void);
main()
{
char *Text1;
Text1 = Func();
}
char *Func(void)
{
char Text2[10]="martin";
return(Text2);
}

'Func' returns a pointer to the memory location where 'Text2' starts BUT Text2 has a
storage class of auto and will disappear when we exit the function and could be
overwritten by something else. The answer is to specify:
static char Text[10]="martin";
The storage assigned to 'Text2' will remain reserved for the duration if the program.

Extern - storage Class
extern defines a global variable that is visable to ALL object modules. When you use
'extern' the variable cannot be initalized as all it does is point the variable name at a
storage location that has been previously defined.
Source 1
-------extern int count;
write()
{
printf("count is %dn", count);
}

Source 2
-------int count=5;
main()
{
write();
}

Count in 'source 1' will have a value of 5. If source 1 changes the value of count - source
2 will see the new value.

What is storage class

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to What is storage class (20)

Recently uploaded (20)

What is storage class