Storage Class

                                                                           STORAGE CLASSES

In addition to data type, each variable has one more attribute known as storage class. The proper use of storage classes makes our program efficient and fast.

The general syntax:

Storage_class   datatype   variable_name;

There are four types of storages classes:

1.       Automatic

2.       External

3.       Static

4.       Register

The keyword auto ,static,register,extern are used for these above storage classes.

A  storage class decides about these four aspects of a  variable:

1.       Life-time: Time between the creation and destruction of a variable.

2.       Scope: Location where the variable is available for use.

3.       Initial value:  Default value taken by an uninitialized variable.

4.       Place of storage: Place in memory where the storage is allocated for the variable.

Automatic:

All the variable declared inside a block/function without any storage class specified are automatic variables.

Lets see the examples:

  #include<stdio.h>

  Void func(void);

  Int main(void);

  {

     Func();

     Func();

     Func();

    Func();

 }

Void func(void)

 {

  Int x=2,y=9;

Printf(“x=%d,y=%d\n”,x,y);

 X++;

 Y++;

}

OUTPUT:

X=2,y=9

X=2,y=9;

X=2,y=9;

X=2,y=9;

Explanation:

Here when the function func() is called for first time , the variable x and y are created and initialized and when the control returns to main() , these variables are destroyed. when the function func() is called for second time again these variables are created and initialized and are destroyed after execution of the function.

Register:

 The scope ,lifetime and initial value of register variables are same as that of automatic variables. The only difference between the two is in the place where they are stored. Automatic variables are stored in memory while register variables are stored in CPU register. Registers are small storage units present in the processor. The variable stored in registers can be accessed much faster than the variables stored in memory so the variables that are frequently used can be assigned  register storage class for faster processing .

Lets see the example:

#include<stdio.h>

 Int main(void)

{

 Register int I;

  For(i=0;i<2000;i++)

  Printf(“%d\n”,i);

Return 0;

}

NOTE: Register variables don’t have memory addresses so we can’t apply address operator (&) to them.

External:

The variables that have to be used by many functions and in different files can be declared as external variables. The initial value of an uninitialized external variable is zero.

Before studying external variables. Lets us first understand the difference between their definition and declaration. The declaration of an external variable declares the type and name of the variable, while the definition reserves storages for the variable as well as behaves as a declaration.

Note: The keyword extern is specified in declaration but not in definition. For example   the definition of an external variable salary will be written as :float salary;

 Its declaration will be written as: extern float salary;

Definition of an external variable:

a)      Definition creates the variable , so memory is allocated at the time of definition.

b)      There can be only one definition

c)       The variable can be initialized with the definition and initializer should be constent

d)      The definition can be written only outside of function.

Declaration of an external variable:

a)      Declaration does not create a variable, it only refers to a variable that has already been created somewhere, so memory is not allocated at the time of declaration.

b)      The variable can not be initialized at the time of declaration

c)      The keyword extern is always specified in the declaration.

Static:

There are two types of static variables:-

1.       Local static variables.

2.       Global static variables.

1.Local static variables

The scope of a local variable is same as that of an automatic variable l.e it can be used only inside the function or block in which it is defined. The lifetime of static variable is more than that  of automatic variable. A static variable is created at the compilation time and it remain alive the end of a program.

A static variable can be initialized only by constant or constant expression if a static variable is not explicitly initialzed then by default it takes initial value zero(‘0’).

Program to understand the use of local static variable:

#include<stdio.h>

 void func(void);

 int main(void)

{

  func();

  func();

  func();

return 0;

} 

 Void func(void)

  {

    Static int x=2,y=5;

    Printf(x=%d,y=  %d\n”,x,y);

   X++;

   Y++;

}

Output:   x=2,y=5

                X=3,y=6

               X=4,y=7

2.Global static variable:

 If a local variable is declared as static then it remains alive throughout the program. In case of global variable, the static specified is not used to extend the lifetime since global variable already have a lifetime equal to the life of program.

If an external variable is defined as static then it can’t be used by other files of the program so we can make an external variable private to a file by making it static.