Define the term Scope, Visibility And Lifetime of a Variable

An object is recognized by the computer by either its identifier or name. The object may be a variable of basic type or a function, a structure, or a union. The macro names and macro variables do not figure in the scope because macros are replaced by the preprocessor token sequences before the semantic phase of program translation. An identifier may also represent different objects in different scopes.

The scope of a variable is the range of program statements that can access that variable. The lifetime of a variable is the interval of time in which storage is bound to the variable. A variable is visible within its scope and invisible or hidden outside it.

The scope of an identifier is that portion of the program code in which it is visible, that is, it can be used. Four types of scopes are defined in C language. These are as follows:

(i) File scope: If the declaration of an identifier is outside any block or list of parameters, it has file scope.

(ii) Block scope: If the declaration of an identifier is inside a block, it has block scope and the scope ends with the end of the block. A block of statements starts with the left brace ({) and ends with the closing right brace (}).

(iii) Function scope: If the declaration of an identifier is inside a list of parameters in function definition, it has function scope, which ends with the end of function definition.

(iv) Function prototype scope: If the declaration of identifier appears within the list of parameters of a function prototype, which is not part of function definition, the scope of identifier is limited to the function prototype. The scope ends with the end of declaration.

Illustrates the scope of variables.

#include <stdio.h>
int A = 20; // file scope
double B = 8.5; //file scope
int main() {
 const double PI = 3.14159;
 const int S= 6; //Value cannot be changed in the program
 clrscr();
 printf("Values in main:\n A= %d\t B = %f\t PI = %f\t S= %d\n", A, B,PI,S) ;
 {
  int A = 18;
  float B= 15.5;
  printf("Values in outer braces:\n A %d\tB %f\tPI %f\tS= %d\n", A, B, PI, S);
 {
 float B = 25.5;
 enum Number{A = 4, C} ;
 /* if A is redefined in the block as well in enum it will result in compilation error.*/
 printf("Value in inner braces:\n A %d\t B %f\t PI %f\t S %d\t C =%d\n", A,B,PI,S,C);
 }
 printf ("Values in the outer braces: \n A %d\t B %f\t PI %f\t S %d\n", A, B, PI,S);
 }
 printf("Values outside the outer braces:\n A= %d\t B = %f\n", A, B);
 printf("Values in file scope A= %d \t B = %f\n", A, B);
 return 0;
}

In the above output, int A = 20 and double B = 8.5 are declared in file scope. If the identifiers are not redefined in main (), then they are visible with the values 20 and 8.5, respectively. In the middle of the program and in the innermost block {} of the program, A and B have been redefined with A as a member of enumeration constant having value 4 and B having value 25.5. This is shown in the sixth line of the output. The scope of these values is only up to the closing of the block in which these have been redefined. In outer curly brackets, the variables A and B have values 18 and 15.5, respectively (eighth line of the output). But the scope of these values is only up to the closing of the outer block. After the closure of inner and outer braces, the values of A and B are again 20 and 8.5, respectively. It is found from the last two lines of the output that the values of A and B remain same as assigned before the main(), while in-between, the values are different. The variables PI and S do not change their values throughout the program because these have been declared as constant. The variables defined in a function have scope only up to the function.