STORAGE CLASSES
Every
variable In C language has a powerful characteristic called Storage Class. There are 3 basic places in a c-program where
variables will be declared:
- Inside the function
- in the definition of function
- Outside of all functions.
These variables are called as
local variables, formal variables and global variables.
Local Variables:
A variable
declared inside a function is called as local variables. A local variable will
be visible to the function in which it is declared.
Global Variables:
A variable
declared in the global variable section are called as global variables. A
global variable can be used anywhere in the program. The proper place of
declaration of global variable is at the beginning of the main program.
#include<stdio.h>
#include<conio.h>
int a=10; // global variable can be accessed from
anywhere in
the program
void main( )
{
clrscr();
{
int x=20; //local variable can be accessed
with in the function or within
the block.
printf(“%d%d”,a,x);
}
printf(“\n%d”,a);
printf(“\n%d,%d”,a,x); //error ‘x’ not accessible
}
Output:
10 20
10
A variable
defined in a block can be accessed within the block and all its inner blocks.
It is called as scope of variable.
While
defining a variable we mentioned only its data type. To fully define a variable
we need to mention not only its data type, but also its storage class. If we
don’t specify it the compiler will assume a default storage class depending on
the context where variable is defined.
In ‘C there
are 4 types of storage classes.
- auto
- static
- register
- extern
The storage
class tells us 4 things:
- Default initial value: what will be the default
initial value of the variable as soon as it is defined
- Location: where the variable would be
stored
- Scope: where the variable can be
accessed.
- Life: How long the memory remains
reserved for the variable.
By default
the storage class for any variable is auto
|
|
Auto
|
Static
|
Register
|
Extern
|
|
Default
initial value
|
Garbage
|
0
|
Garbage
|
0
|
|
Location
|
RAM
|
RAM
|
CPU
Registers
|
RAM
|
|
Scope
|
Local to
the block where the variable is defined
|
Local to
the block where the variable is defined
|
Local to
the block where the variable is defined
|
Entire
Program
|
|
Life
|
As long
as the control is within the block where
the variable is defined
|
As long
as the program is under execution
|
As long
as the control is within the block where
the variable is defined
|
As long
as the program is under execution
|
/* Auto
Storage Class */
#include<stdio.h>
#include<conio.h>
void fun()
{
int a=10;
printf("%d\n",a);
a++;
}
void main()
{
fun();
fun();
fun();
}
Output:
10
10
10
Here the
storage class is auto be default. Auto variable life is as long as the control
is within the block where the variable is defined. Whenever the statement, int
a=10; gets executed, memory gets allocated to ‘a’ and the location is
initialized with 10. Whenever the control comes out of the fun( ) function
block, the variable ‘a’ dies, i.e., memory allocated gets released and hence
the output.
/* Static
Storage Class */
#include<stdio.h>
#include<conio.h>
void fun()
{
static int a=10;
printf("%d\n",a);
a++;
}
void main()
{
fun();
fun();
fun();
}
Output:
10
11
12
Static
variable life is as long as the program is under the execution. These variables
gets memory allocated as soon as the program gets loaded into memory and memory
gets deallocated just before the termination of the program from the memory.
Static int a=10;
gets
executed only once and when the control enters the fun () for the next time the
line gets ignored so it has the value what is has the last time. Its value
persists between different function calls, and hence the output. These are
local to the block.
/*
register storage class */
These
variables are accessed much quickly than other variables as they reside in the
registers of the microprocessor. Because of the limited size and number of
registers available, few variables can actually be put in registers. If the
compiler does not allocate a machine register for a variable, then the variable
is treated as auto. We cannot use register for all types of variables (for ex.,
long, float, double) because the CPU registers are usually 16-bit registers. As
these are declared in registers these cannot be referred by the pointer variable.
The variables of most frequent use should only be of register type.
#include<stdio.h>
#include<conio.h>
void main()
{
register int i;
for (i=1;i<=100;i++)
printf("Hai");
}
Here the i
gets accessed around 100 times so if it is made to reside in cpu registers
program execution will be fast.
Output:
HaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHaiHai
/* extern
storage class */
When there
is a need for a variable to be accessed in all the functions in a program then
the external variables serve the purpose.
#include<stdio.h>
#include<conio.h>
int a; /* by default a is 0 */
void main()
{
a=a+1;
clrscr();
printf("%d\t",a);
fun1();
fun2();
fun3();
fun4();
getch();
}
fun1()
{
a=a+10;
printf("%d\t",a);
}
fun2()
{
a=a+5;
printf("%d\t",a);
}
fun3()
{
a=a-2;
printf("%d\t",a);
}
fun4()
{
a=a+8;
printf("%d\t",a);
}
Output:
1 11
16 14 22
