Concept of Local, Global and Static Variables in C programming

   Local Variables (automatic or internal variable):

The automatic variables are always declared within a function or block and are local to the particular function or block in which they are declared. As local variables are defined within the body of the function or the block, other functions can not access these variables. The compiler shows errors in case other functions try to access the variables.

          Default Initial value of such type of variable is an unpredictable value which is often called garbage value. The scope of it is local to the block in which the variable is defined. Again, its life is till the control remains within the block in which the variable is defined. The keyword auto may be used while declaration of variable. For example, auto int a; But this is normally not done.

        /*An example to illustrate local variable*/

     #include<stdio.h>

          long int fact(int n)

               {

                     int i;

                     long int f=1;

                     for(i=1;i<=n;i++)

                             f*=1;

                    return(f); 

                     }

void main()

             {

                int num=5;

                printf(“The factorial of 5 is%ld”,fact(num));

                 }

Here, the variables n, i , and f are local to function fact() and are unknown to main() function.

Global Variables (External):

               The external or global variables are those variables declared outside any block or function. The default initial value for these variables is zero. The scope is global i.e. within the program. The life time is as long as the program’s execution doesn’t come to an end. The keyword extern can be used to identify the global variable. But, since the variables declared outside any block are global by default, there is no need of using extern.

  An example to illustrate the global variables,

           #include<stdio.h>

          #include<conio.h>

          int a=10;

         void fun()

                  {

            a=20;

            printf(“\t%d”,a++);

           }

 void main()

         {

           printf(“\t%d”,a);

           fun();

           printf(“\t%d”,a);

        }

Output:

         10     20        21

Static Variables:

          The static variables are defined using keyword static.  The default initial value for this type of variable is zero if user doesn’t initialize its value. Its scope is local to the block in which the variable is defined. Again, the life time is global i.e. its value persists between different function calls.      

 Examples:

   With auto variables                             With static variables

  increment()                                            increment()

          {                                                                {

            int i=1;                                                           static int i=1; /* here  i is static variable*/

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

           i++;                                                                  i++;

           }                                                                  }

void main()                                                        void main()

            {                                                                      {

            increment();                                                        increment();

            increment();                                                        increment();

            increment();                                                         increment();

            increment();                                                         increment();

            }                                                                           }

Output :

1                                        1

1                                        2

1                                        3

1                                        4

  The static variable doesn’t disappear when the function is no longer active. Their values persist. if control comes back to the same function again, the static variables have the same values they    had last time around.