2.5 Functions and pointers  (Page 4/11)

From main(): y = 20

From valfun(): x = 10

From valfun(): y = 30

From main() again: x = 40

From main() again: y = 20

In the above program, the variable x is a global variable because its storage is created by a definition statement located outside a function. Both functions, main() and valfun() can use this global variable with no further declaration needed. The program also contains two separate local variables, both named y. Each of the variables named y is local to the function in which their storage is created, and each of these variables can only be used within the appropriate functions.

Scope resolution operator

When a local variable has the same name as a global variable, all uses of the variable’s name within the scope of the local variable refer to the local variable.

In such cases, we can still access to the global variable by using scope resolution operator (::) immediately before the variable name.

The :: operator tells the compiler to use the global variable.

Example

#include<iostream.h>

float number = 42.8; // a global variable named number

int main()

{

float number = 26.4; // a local variable named number

cout<<"The value of number is "<<number<<endl;

return 0;

}

The output of the above program:

The value of number is 26.4

Example

#include<iostream.h>

float number = 42.8; // a global variable named number

int main()

{

float number = 26.4; // a local variable named number

cout<<"The value of number is "<<::number<<endl;

return 0;

}

The output of the above program:

The value of number is 42.8

Variable storage class

The lifetime of a variable is referred to as the storage duration , or storage class.

The four available storage classes are auto , static , extern and register .

If one of these class names is used, it must be placed before the variable’s data type in a declaration statement.

Examples:

auto int num;

static int miles;

register int dist;

extern float price;

extern float yld;

Local variable storage classes

Local variables can only be members of the auto, static, or register storage classes.

If no class description is included in the declaration statement, the variable is automatically assigned to the auto class.

Automatic variables

The term auto is short for automatic. Automatic storage duration refers to variables that exist only during the lifetime of the command block (such as a function) that contains them.

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)

{

int sum = 100; // sum is a local auto variable

sum += x;

return sum;

}

The output of the above program:

1 101

2 102

3 103

4 104

5 105

6 106

7 107

8 108

9 109

10 110

Note: The effect of increasing sum in funct(), before the function’s return statement, is lost when control is returned to main().

In some applications, we want a function to remember values between function calls. This is the purpose of the static storage class.

A local static variable is not created and destroyed each time the function declaring the static variable is called. Once created, local static variables remain in existence for the life of the program.