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.
Comments
Post a Comment