Global variables

We have seen that a general C program is basically a collection of functions. Furthermore, the variables used by these functions are local in scope: i.e., a variable defined in one function is not recognized in another. The main method of transferring data from one function to another is via the argument lists in function calls. Arguments can be passed in one of two different manners. When an argument is passed by value then the value of a local variable (or expression) in the calling routine is copied to a local variable in the function which is called. When an argument is passed by reference then a local variable in the calling routine shares the same memory location as a local variable in the function which is called: hence, a change in one variable is automatically mirrored in the other. However, there is a third method of transferring information from one function to another. It is possible to define variables which are global in extent: such variables are recognized by all the functions making up the program, and have the same values in all of these functions.

The C compiler recognizes a variable as global, as opposed to local, because its declaration is located outside the scope of any of the functions making up the program. Of course, a global variable can only be used in an executable statement after it has been declared. Hence, the natural place to put global variable declaration statements is before any function definitions: i.e., right at the beginning of the program. Global variables declarations can be used to initialize such variables, in the regular manner. However, the initial values must be expressed as constants, rather than expressions. Furthermore, the initial values are only assigned once, at the beginning of the program.

The program listed below is yet another version of printfact.c, in which communication between the two sections of the program takes place entirely via global variables:

/* printfact4.c */
/*
  Program to print factorials of all integers
  between 0 and 20
*/

#include <stdio.h>
#include <stdlib.h>

/* Prototype for function factorial() */
void factorial();
   
/* Global variable declarations */
int j;             
double fact;

int main() 
{
  /* Print factorials of all integers between 0 and 20 */
  for (j = 0; j <= 20; ++j) 
   {
    factorial();
    printf("j = %3d    factorial(j) = %12.3e\n", j, fact);
   }
  return 0;
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

void factorial() 
{
  /* 
     Function to evaluate factorial (in floating-point form)
     of non-negative integer j. Result stored in variable fact.
  */

  int count;

  /* Abort if j is negative integer */
  if (j < 0) 
   {
    printf("\nError: factorial of negative integer not defined\n");
    exit(1);
   }

  /* Calculate factorial */
  for (count = j, fact = 1.; count > 0; --count) fact *= (double) count;

  return;      
}

The output from the above program is identical to that from printfact.c. Observe that the global variable j is used to pass the integer value whose factorial is to be calculated from the main part of the program to the function factorial(), whilst the global variable fact is used to pass the calculated factorial back to the main part of the program. Incidentally, note the use of multiple initialization statements (separated by commas) in the for statement appearing in factorial().

Global variables should be used sparingly in scientific programs (or any other type of program), since there are inherent dangers in their employment. An alteration in the value of a global variable within a given function is carried over into all other parts of the program. Unfortunately, such an alteration can sometimes happen inadvertently, as the side-effect of some other action. Thus, there is the possibility of the value of a global variable changing unexpectedly, resulting in a subtle programming error which can be extremely difficult to track down, since the offending line could be located anywhere in the program. Similar errors involving local variables are much easier to debug, since the scope of local variables is far more limited than that of global variables.