Example
#include<iostream.h>
int funct( int); // function prototype
int main()
{
int count, value; // count is a local auto variable
for(count = 1; count<= 10; count++)
value = funct( count);
cout<<count<<‘\t’<<value<<endl;
return 0;
}
int funct( int x)
{
static int sum = 100; // sum is a local auto variable
sum += x;
return sum;
}
The output of the above program:
1 101
2 103
3 106
4 110
5 115
6 121
7 128
8 136
9 145
10 155
Since sum has a permanent memory space it retains the same value in the period of time between leaving function and again entering it later.
Note:
- The initialization of static variables is done only once when the program is first compiled. At compile time, the variable is created and any initialization value is placed in it. Thereafter, the value in the variable is kept without further initialization each time is called. (compile-time initialization).
- All static variables are set to zero when no explicit initialization is given.
Register variables
Register variables have the same time duration as automatic variables. The only difference between register and automatic variables is where the storage for the variable is located.
Register variables are stored in CPU’s internal registers rather than in memory.
Examples:
register int time;
register double difference;
Global variable storage classes
Global variables are created by definition statements external to a function. Once a global variable is created, it exists until the program in which it is declared is finished executing.
Global variables may be declared as static or extern (but not both).
The purpose of the extern storage class is to extend the scope of a global variable beyond its normal boundaries. To understand this, we must notice that the programs we have written so far have always been contained together in one file. Thus, when you have saved or retrieved programs, you have only needed to give the computer a single name for your program. Larger programs typically consist of many functions stored in multiple files and all of these files are compiled separately. Consider the following exaple.
Example:
//file1
int a;
float c;
static double d;
.
.
int main()
{
func1();
func2();
func3();
func4();
.
}
int func1();
{
.
.
}
int func2();
{
.
.
}
//end of file1
//file2
double b;
int func3();
{
.
.
}
int func4();
{
.
.
}
//end of file2
Although the variable a has been declared in file1, we want to use it in file2. Placing the statement extern int a in file2, we can extend the scope of the variable a into file2.
Now the scope of the variable a is not only in file1, but also in func3 and func4.
//file1
int a;
float c;
static double d;
.
.
int main()
{
func1();
func2();
func3();
func4();
.
}
extern double b;
int func1();
{
.
.
}
int func2();
{
.
.
}
//end of file1
//file2
double b;
extern int a;
int func3();
{
.
.
}
int func4();
{
extern float c;
.
.
}
//end of file2
Besides, placing the statement extern float c; in func4() extends the scope of this global variable, created in file1, into func4(), and the scope of the global variable b, created in file2, is extended into func1() and func2() by the declaration statement extern double b; placed before func1().