Storage classes in c

In c there are four types of storage class. They are:

1. auto
2. register
3. static
4. extern
Storage class is modifier or qualifier of data types which decides:

1.  In which area of memory a particular variable will be stored?  

2. What is scope of variable?
3. What is visibility of variable?

Visibility of a variable in c:

    Visibility means accessibility. Up to witch part or area of a program, we can access a variable, that area or part is
known as visibility of that variable. For example: In the following figure yellow color represents visibility of
variable a.

Scope of a variable in c:

    Meaning of scope is to check either variable is alive or dead. Alive means data of a variable has not destroyed
from memory. Up to which part or area of the program a variable is alive, that area or part is known as scope of a
variable. In the above figure scope of variable a represented outer red box i.e. whole program.
Note: If any variable is not visible it may have scope i.e. it is alive or may not have scope. But if any variable has not
scope i.e. it is dead then variable must not to be visible.

There are four type of scope in c:

1. Block scope.
2. Function scope.
3. File scope.
3. Program scope.

Block scope:

    In c block is represented area between opening curly bracket i.e. {and closing curly bracket i.e.}. Example of
blocks in c.
In the c code there are three blocks shown in yellow color. In the above code one more block which is main function
block. If a variable or function has scope only within the scope where it has declared then scope of variable or
function is called as block scope and if a variable or function is visible is only within a block where it has declared
then that variable or function is called as block visible.  

Function block:

A block of function body has special name, function block. From storage class point of view there is not any
difference between function block and any other blocks in c. Because there is not any modifiers of storage class
group which has function block. Importance of function block can understand when we deal with goto statement.
Label of goto statement has function block scope. Label of particular goto statement is not visible in another
function. For example:

#include<stdio.h>
void display();
int main(){
    printf("In MAIN");   
    goto xyz;
    return 0;
}
void display(){
    xyx:;
    printf("In DISPLay");
}

Output: Compilation error

File scope:
    If any variable or function has scope only within a file where it has declared then scope of variable or function is
known file scope. If any variable or function is visible only within a file where it has declared then visibility of that
variable or function is called file visible.
Program scope:
    If any variable or function has scope whole of the program, program may contain one or more files then scope of
variable or function is known program scope. If any variable or function which is visible in the whole program,
program may contain one or more file then variable or function, that variables or functions are called as program
visible.

Scope and visibility of storage class:

auto storage class in c

auto:
Automatic variables or auto variables are default storage class of local variable. An auto variable cannot be declared
globally. (Why?)

Properties of auto storage class.

(1) Default initial value of auto variable is garbage. For example:

#include<stdio.h>
int main(){
    int i;
    auto char c;
    float f;
    printf("%d  %c  %f",i,c,f);
    return 0;
}
Output: Garbage Garbage Garbage

(2)Visibility of auto variable is within the block where it has declared. For examples:

(a)
#include<stdio.h>
int main(){
    int a=10;
    {
         int a=20;
         printf("%d",a);
    }
    printf(" %d",a);
    return 0;
}

Output: 20 10
Explanation: Visibility of variable a which has declared inside inner has block only within that block.
(b)
#include<stdio.h>
int main(){
    {
         int a=20;
         printf("%d",a);
    }
    printf(" %d",a);  //a is not visible here
    return 0;
}

Output: Compilation error

Explanation: Visibility of variable a which has declared inside inner block has only within that block.

Question: What will be output of following c code?

#include<stdio.h>
int main(){
    int a=0;
    {
         int a=10;
         printf("%d",a);
         a++;
         {
             a=20;
         }
         {
             printf(" %d",a);
             int a=30; {a++;}
             printf(" %d",a++);
         }
         printf(" %d",a++);
    }
    printf(" %d",a);
    return 0;
}

(3) Scope of auto variable is within the block where it has declared. For example:

(a)
#include<stdio.h>
int main(){
    int i;
    for(i=0;i<4;i++){
         int a=20;
         printf("%d",a);
         a++;
    }
    return 0;
}

Output: 20 20 20 20
Explanation: Variable declared inside the for loop block has scope only within that block. After the first iteration
variable a becomes dead and it looses its incremented value. In second iteration variable a is again declared and
initialized and so on.

(b)
#include<stdio.h>
int main(){
    int i=0;
    {
         auto int a=20;
         XYZ:;
         printf("%d",a);
         a++;
         i++;
    }
    if (i<3)
         goto xyz;
    return 0;
}

Output: Compilation error.

Explanation: Variable a which declared inside inner block has scope only within that block. Ones program control
comes out of that block variable will be dead. If with the help of goto statement we will go to inside that inner block
in the printf statement complier will not known about variable a because it has been destroyed already. Hence
complier will show an error message: undefined symbol a. But if you will write goto statement label before the
declaration of variable then there is not any problem because variable a will again declared and initialize.

#include<stdio.h>
int main(){
    int i=0;
    {
         XYZ:;
         auto int a=20;
         printf("%d",a);
         a++;
         i++;
    }
    if (i<3)
         goto xyz;
    return 0;
}

Output: 20 20 20

(4) From above example it is clear auto variable initialize each time.

(5)An auto variable gets memory at run time.

Register storage class specifiers in c with example
A register storage class is very similar to auto storage class except one most important property. All register variable
in c stores in CPU not in the memory.

Important points about register storage class

(1)In following declaration:

    register int a;

We are only requesting not forcing to compiler to store variable a in CPU. Compiler will decide where to store in the
variable a.

(2)A register variable execute faster than other variables because it is stored in CPU so during the execution
compiler has no extra burden to bring the variable from memory to CPU.

(3)Since a CPU have limited number of register so it is programmer responsibility which variable should declared as
register variable i.e. variable which are using many times should declared as a register variable.

(4) We cannot dereference register variable since it has not any memory address. For example:
     
(a)
#include<stdio.h>
int main(){
    register int a=10;
    int *p;
    p=&a;
    printf("%u",p);
}

Output: Compilation error

(b)
#include<stdio.h>
int main(){
    register int a,b;
    scanf("%d%d",&a,&b);
    printf("%d  %d",a,b);
}

Output: Compilation error

(5) Default initial value of register variable is garbage.

(6) Scope and visibility of register variable is block.