Variable definitions were introduced in the section called “The Basics of Variable Definitions”. We will now examine them in greater detail. A variable definition allocates memory to store a value, and assigns the memory location a name and a data type. The compiler uses the data type to determine which machine instructions to use to process the data. For example, adding two integers is done with a different machine instruction than adding two floating point values. The integer add instruction is faster, so defining a variable as int rather than double will lead to a faster program.

A C variable definition consists of a data type followed by one or more variable names separated by commas, and ultimately a semicolon:

type name [, name ...]; 
        

double height, width, area; 
        

A Fortran 90 variable definition consists of a type, followed by two colons, followed by a list of variable names separated by commas:

type :: name [, name ...]
        

real(8) :: height, width, area 
        

Variable names must begin with a letter or an underscore, and may contain letters, underscores, and digits after that.

The words “definition” and “declaration” are often used interchangeably in programming. In the context of languages such as C and C++, definition and declaration have different meanings. A definition in C allocates memory, whereas a declaration merely alludes to a variable or function defined elsewhere. For example, all C programs contain a global variable called errno, which contains the error code from the most recent standard library function. We can declare it in a given function by using the extern modifier to tell the compiler that this variable is defined somewhere else and we want to access it from here:

    extern int  errno;  // Declare (allude to), not define, errno
        

Without the extern modifier, we would be defining a new local variable called errno rather than alluding to the one already defined globally. The local variable would take precedence over the preexisting global variable under the variable scope rules of C, which means it would be impossible to access the global variable where the local variable is defined.

Note that while we can declare errno using an allusion as shown above, the modern method is to include errno.h, which contains this allusion:

#include <errno.h>
        

double sum = 0.0;
            

real(8) :: sum = 0.0d0
            

double  sum;

// Suppose there are 100 lines of additional code here

// A cohesive block of code
sum = 0.0;
for (c = 0; c < list_size; ++c)
    sum += value;
            

double  sum = 0.0;

// Suppose there are 100 lines of additional code here

// This is not cohesive since the initialization of sum is far away from
// the loop that requires it
for (c = 0; c < list_size; ++c)
    sum += value;
            

double  height, width, area;
int     list_size, age; 
            

real(8) :: height, width, area
integer :: list_size, age