Every variable in C programming language has two properties; type and storage class. 'Type' refers to the data type of the variable such as integer, character, floating point values etc. It also deals with the size of the variable ( in bytes). 'Storage class' determines the part of memory where storage is allocated for the variable and how long the storage allocation continues to exist. It also determines the scope which specifies the part of the program over which a variable name is visible, i.e. the variable is accessible by name. The scope restriction can be overrode by making use of pointers. Whatever, in short, storage class is the property that determines the part of memory where storage is allocated, the lifetime of variable and the scope of the variable.
There are for storage classes in C programming:
- Automatic
- Register
- External
- Static
Automatic variables:
'Aromatic' or 'auto' is the storage class which is default for all local variables, i.e. variables declared inside a function or a block is automatic by default. They are normally declared s at the start of the block. Memory is allocated automatically upon entry to a block and freed automatically upon exit from the block. The scope of automatic variables is local to the block in which they are declared, including any blocks nested within the block. For these reasons, automatic variables are often referred to as 'local variables'. Since any variable declared inside a block or a function is 'local' by default, the keyword 'auto' which is used to declare automatic variables, are rarely used.
int fact(int n)
{
auto int result; /* automatic variable declaration*/
if(n==0)
result =1;
else
result =n*fact (n-1);
return (result);
}
In above example, an automatic integer variable 'result' is declared within the function 'fact'. The variable is local to the function as it's declared as automatic. But, it is not necessary to use the keyword 'auto' because even if auto is avoided, the variable will be auto by default.
Register Variables:
A Register variable is a special case of automatic variable. Register variables are identical to automatic variables in the case of scope, i.e, they are local to the function or block in which they are declared. The only difference is in the part of memory in which the storage is allocated. An automatic variable is always stored in RAM whereas, as the name indicates, register variables are stored in registers. When we consider a program in which a certain variable is frequently used, the performance of the program can be improved if it is stored in a register instead of RAM since registers are very much faster memory components than RAM. Variables used in enormously repeated loops of large programs, variables used as parameters for frequently called functions etc. can be declared as register variables in order to increase the performance of the program considerably.
To declare a register variable, the keyword 'register' should be prefixed to the data type as shown:
register int a;
When the compiler encounters a register variable declaration, it tries to store the variable in microprocessor's register rather than RAM. Value stored in registers are much faster than those in RAM. Since the number of registers are limited, if it couldn't be stored in register it will store it in RAM. Even the availability of resisters doesn't guarantee faster execution of program. For example, if too many register variables are declared and there are not enough registers to store all of them, values in some of the registers would have to be moved to temporary storage in memory in order to clear those registers for other variables. Thus much time may be wasted in shipping the data in and out of the registers. In addition, careless use of register variables may interfere with other uses of registers by the compiler, such as storage of temporary values in expression evaluation. In short, the keyword 'register' should be used carefully and lavish usage may result in slower execution of program.
External variables:
In some applications it may be helpful to have data which is accessible from within any block and/or which remains in existence for the entire execution of program. Such variables are called global variables, and the C language provides storage classes which can meet these requirements; namely, the external storage class.
External variables may be declared outside any function block in a source code file the same way any other variable is declared; by specifying its type and name. No storage class specifier is used -- the position of the declaration within the file indicates external storage class. Memory fit such variables is allocated when the program begins execution, and remains allocated until the program terminates. For most C implementations, every byte of memory allocated for an external variable is initialised to zero. The scope of the external variable is global,i.e. the entire source code in the file following the declarations. All functions following the declaration may access the external variable by using its name. However, if a local variable having the same name is declared within a function, references to the name access the local variable cell.
#include<stdio.h>
int m=0; /* External variable */
main ()
{
int m=1; /* auto variable */
printf("m=%d",m);
}
The output of this code is:
m=1
Static variable
The difference between static and automatic storage class is that the lifetime of a static variable is more than that of the automatic variable. The difference between them is that static variable do not disappear when the function is no longer active. There value persist. If control comes back to the same function again , the static variables have the same values they had last time around. The difference can be easily understood by comparing two programs with same variable with different storage classes. Let us compare two programs and their outputs.
#include<stdio.h>
void findsum(int a)
{
auto int sum=0; /*automatic*/
sum+=a;
printf("\nsum=%d",sum);
}
void main()
{
int p;
for(p=1;p<4;p++)
{
findsum(p);
}
} | #include<stdio.h>
void findsum(int a)
{
static int sum=0; /*static*/
sum+=a;
printf("\nsum=%d",sum);
}
void main()
{
int p;
for(p=1;p<4;p++)
{
findsum(p);
}
} |
| |
Output:
sum=1
sum=2
sum=3 | Output:
sum=1
sum=3
sum=6
|
In the first example, the variable
sum in
findsum() is declared as an automatic variable while it is static in second example. In first example, at the first call of function
findsum() (when p=1), the variable sum in the function is initialized as with zero. After the completion of execution of the function
findsum(), the life of variable
sum ends. In the next call, again
sum is allocated and initialised. So, each time the number is going to be added, the initial value of
sum will be 0.
In second example, once the function gets executed, the variable
sum is allocated and initialised with zero. Since it is declared as a static variable, the line
static int sum=0; will not be executed in the next executions of the function. i.e. the declaration statement (along with initialisation if any) will not be executed each time the function is called. Moreover, if one execution of the function is over, the static variable will not be deallocated. If control comes back to the same function again , the static variables have the same values they had last time around. There for the variable
sum will give cumulative values in second example.
