Previous: 3.3.1 The C Preprocessor
Up: 3.3 Coding Programs for Readability
Next: 3.3.3 Including Header Files
Previous Page: 3.3.1 The C Preprocessor

3.3.2 Macros

In Chapter we introduced the define compiler directive which defines symbolic names for strings of characters. Such a string of characters can be arbitrary, for example a sequence of characters representing a numeric constant. These names can then be used anywhere in the program instead of the string itself. The C preprocessor replaces these symbolic names with the specified strings prior to compiling the program. We have seen examples where using names for arbitrary strings makes it easy to change all occurrences of these names by merely changing the definitions. It also makes for easier reading and debugging of programs by allowing the programmer to use a name which has some meaning rather than some ``magic number''.

The definition is called a macro and the preprocessor performs a macro expansion when it substitutes the string for the name. A macro definition takes the form:

• #define <symbol_name> <substitution_string>

The macro names follow the same rules as identifiers, however, a common convention observed by most C programmers is to name macros in all upper case to distinguish them from program variables. No quotation marks are used to delimit the string, nor is the directive terminated by a semi-colon. Instead, the string extends to the end of the line (an escape character, , can be used to continue the string on the next line). For example, the following are macro definitions:

#define     PI          3.14159
                #define     SIZE        1000
                #define     RSQUARED    radius * radius
                #define     AREA        PI * RSQUARED
                #define     LONG        This is a very long macro  
                definition we continued to the next line

When directives such as these appear in the source file, then the macros are said to have been defined. We have defined macros for the symbols PI, SIZE, RSQUARED, AREA and LONG. With the above definitions, the defined names may be used anywhere in program statements. The preprocesser generates the expanded source code by string replacement, for example:

Original code         Expanded code after preprocessing

         circum = 2 * PI * radius;    circum = 2 * 3.14159 * radius;
         y = x + SIZE;                y = x + 1000;
         printf("SIZE = ",SIZE);      printf("SIZE = ",1000);
         AREA;                        3.14159 * radius * radius;

As can be seen, the preprocessor replaces the macro name with the specified replacement string in the entire source file following the definition. The substitution is not made if a macro name, occurs in double quotes as in the format string in the printf() statement shown above.

The scope of the macro definition is the entire source file following the definition line. The definitions may be removed at any point in the program by a directive #undef, for example:

#undef SIZE

The above directive makes the preprocessor ``forget'' the previous definition for SIZE. If desired, a new definition may be specified for SIZE at this point. It is a common practice to put macro definitions at the top of the source file, unless the old definitions are removed at some point in the source file and new definitions are specified:

#define SIZE 40          /* SIZE is define to be the string 40 */
     ...
     #undef SIZE              /* SIZE is undefine */
     #define SIZE 100         /* SIZE is defined to be 100 */

Identical definitions for identifiers may appear in a file without causing any problems; however, two different definitions for an identifier represent an error.

#define SIZE 40
     #define SIZE 40     /* OK */
     #define SIZE 100    /* ERROR */

The only way to make a new definition for an identifier is to first undefine it, i.e. remove its first definition.

Macros with Arguments

Macro definitions may also have formal parameters which are replaced by the actual arguments given in the macro call. This is similar to parameters in function calls; however, macro arguments are treated as strings of characters and are substituted for parameters by the preprocessor; no evaluation takes place. Consider the example:

#define READ_FLT(fvar)   scanf("%f", &fvar)

macro call          Expanded Code

             READ_FLT(x);         scanf("%f", &x);
             READ_FLT(rate);      scanf("%f", &rate);

#define SQ(x)       (x * x)

y = SQ(radius);
     printf("Square of %d is %d\n", radius, SQ(radius));

SQ(x+y)

(x + y * x + y)

#define SQ(x)  ((x) * (x))

SQ(x+y)

((x + y) * (x + y))

/* File: macro.c */
     #define READ_FLT(fvar)   scanf("%f", &fvar)
     #define PI     3.14159
     #define SQ(x)  ((x) * (x))

     main()
     {
          float radius;

          printf("Type Radius: ");
          READ_FLT(radius);
          printf("Area of a circle with radius %6.2f is %6.2f\n",
                    radius, PI * SQ(radius));
     }

• Type Radius: 10
• Area of a circle with radius 10.00 is 314.15

An Example Program

Let us look at another example program to make use of these new facilities.

Task

Read a set of high temperature readings for some number of days and to count the number of nice days, bad days, and the average temperature for the period. Nice days are those days whose temperature falls within some ``comfort zone''.

The high level algorithm for this task is straight forward;

prompt the user and read first temperature
      while there are more days to read
            process one day's temperature
            accumulate total temperature
            read the next temperature
      print results

prompt the user and read first temperature
      while there are more days to read
            if it's a nice day, count a nice day
            otherwise count a bad day
            accumulate total temperature
            read the next temperature
      print results

It should be noted we have made an additional design decision here; we use a zero value for the temperature read in as the loop termination. Also not that we have provided prototype statements for our functions, nice_day() and print_results(). This is sufficient information about these functions when considering the logic of main(). (We have specified the return value of print_results as type int, but the function has no real meaningful return value).

We next turn out attention to the function, nice_day(). This function is given the temperature and should return True if this qualifies as a nice day, and False otherwise. The task specified that the temperature of a nice day is to fall within some ``comfort zone'', i.e. not too cold and not too hot. We can write the algorithm for this function from this information:

if temperature is too cold, return False
      if temperature is too hot, also return False
      otherwise, this is a nice day, return true

#define   TOO_COLD      80
#define   TOO_HOT       90

#define   HOT_DAY(t)    ((t) > TOO_HOT)
#define   COLD_DAY(t)   ((t) < TOO_COLD)

print number of nice days and bad days
      if there are any days counted
            compute the average temperature
            print the average temperature

Compiling and executing this program with some sample data produces the following sample session:

• ***Count Nice Days***
• Type daily high temperature readings (0 to quit): 83
• 85
• 88
• 92
• 94
• 86
• 82
• 80
• 79
• 0
• There were 6 nice days and 3 bad days
• The average temperature for 9 days was 85.444443