DEFINES AND MACROS ARE AIDS TO CLEAR PROGRAMMING

 

                       Chapter 6 - Defines and Macros

              DEFINES AND MACROS ARE AIDS TO CLEAR PROGRAMMING

             Load and display the file named DEFINE.C for your first

        look  at  some defines and macros.  Notice  the  first  four

        lines  2  through 5 of the program, each starting  with  the

        word "#define".  This is the way all defines and macros  are

        defined.  Before the actual compilation starts, the compiler

        goes  through  a  preprocessor pass to resolve  all  of  the

        defines.   In the present case, it will find every place  in

        the  program where the combination "START" is found  and  it

        will  simply  replace  it  with the  0  since  that  is  the

        definition.   The  compiler itself will never see  the  word

        "START",  so as far as the compiler is concerned, the  zeros

        were always there.  Note that if the word "START" appears in

        a  text  string  or  a  comment,  it  will  be  ignored  and

        unchanged.

             It should be clear to you by now that putting the  word

        "START"  in your program instead of the numeral 0 is only  a

        convenience  to you and actually acts like a  comment  since

        the  word "START" helps you to understand what the  zero  is

        used for.

             In  the  case  of a very small program,  such  as  that

        before  you,  it doesn't really matter what  you  use.   If,

        however,  you  had a 2000 line program before  you  with  27

        references  to  the  "START",  it  would  be  a   completely

        different  matter.   If  you wanted to  change  all  of  the

        "START"s in the program to a new number, it would be  simple

        to change the one #define, but difficult to find and  change

        all   of  the  references  to  it  manually,  and   possibly

        disastrous if you missed one or two of the references.

             In  the  same manner,  the preprocessor will  find  all

        occurrences of the word "ENDING" and change them to 9,  then

        the  compiler  will  operate  on the changed  file  with  no

        knowledge that "ENDING" ever existed.

             It is a fairly common practice in C programming to  use

        all  capital letters for a symbolic constant such as "START"

        and  "ENDING"  and use all lower case letters  for  variable

        names.  You can use any method you choose since it is mostly

        a matter of personal taste.

                           IS THIS REALLY USEFUL?

             When  we  get  to the  chapters  discussing  input  and

        output,  we  will need an indicator to tell us when we reach

        the end-of-file of an input file.  Since different compilers

        use different numerical values for this,  although most  use

        either a zero or a minus 1, we will write the program with a

                                  Page 43

                       Chapter 6 - Defines and Macros

        "define"  to define the EOF used by our particular compiler.

        If at some later date,  we change to a new compiler, it is a

        simple matter to change this one "define" to fix the  entire

        program.  In Turbo C, the EOF is defined in the STDIO.H file

        on  line 44.  You can observe this for yourself  by  listing

        this  file.

                              WHAT IS A MACRO?

             A macro is nothing more than another define, but  since

        it is capable of at least appearing to perform some  logical

        decisions  or  some math functions, it has  a  unique  name.

        Consider line 4 of the program on your screen for an example

        of  a macro.  In this case, anytime the  preprocessor  finds

        the  word  "MAX"  followed by a  group  in  parentheses,  it

        expects  to find two terms in the parentheses and will do  a

        replacement  of the terms into the second definition.   Thus

        the  first  term  will  replace  every  "A"  in  the  second

        definition and the second term will replace every "B" in the

        second definition.  When line 13 of the program is  reached,

        "index" will be substituted for every "A", and "count"  will

        be  substituted for every "B". But this replaceing will  not

        take place in string literals or comments.  Remembering  the

        cryptic  construct we studied a couple of chapters ago  will

        reveal  that "mx" will receive the maximum value of  "index"

        or "count".

             In  like  manner, the "MIN" macro will result  in  "mn"

        receiving  the  minimum value of "index"  or  "count".   The

        results are then printed out.  There are a lot of  seemingly

        extra  parentheses in the macro definition but they are  not

        extra,  they  are  essential.  We  will  discuss  the  extra

        parentheses in our next program.

             Compile and run DEFINE.C.

                         LETS LOOK AT A WRONG MACRO

             Load  the  file named MACRO.C and display  it  on  your

        screen for a better look at a macro and its use.  The second

        line  defines a macro named "WRONG" that appears to get  the

        cube of "A",  and indeed it does in some cases, but it fails

        miserably in others.  The second macro named "CUBE" actually

        does get the cube in all cases.

             Consider  the program itself where the CUBE of i+offset

        is  calculated.   If  i is 1,  which it is  the  first  time

        through,  then  we will be looking for the cube of 1+5 =  6,

        which  will result in 216.  When using "CUBE",  we group the

        values like this, (1+5)*(1+5)*(1+5) = 6*6*6 = 216.  However,

        when we use WRONG,  we group them as 1+5*1+5*1+5 = 1+5+5+5 =

                                  Page 44

                       Chapter 6 - Defines and Macros

        16 which is a wrong answer.   The parentheses are  therefore

        required  to  properly  group the  variables  together.   It

        should  be clear to you that either "CUBE" or "WRONG"  would

        arrive  at  a correct answer for a single  term  replacement

        such as we did in the last program.   The correct values  of

        the  cube  and the square of the numbers are printed out  as

        well as the wrong values for your inspection.

             Inspection   of  line  24  will  reveal  that  we   are

        evaluating  "5*(i) + (i)" which is 6 if "i" is one,  and  in

        the  second case "5*((i) + (i))" which is 10 if "i' is  one.

        The parentheses around the entire expression assure that the

        value will be evaluated correctly.

                      WHAT IS AN ENUMERATION VARIABLE?

             Load  and  display  the program  named  ENUM.C  for  an

        example  of  how to use the "enum" type  variable.   Line  4

        contains the first "enum" type variable named "result" which

        is a variable which can take on any of the values  contained

        within  the parentheses.  Actually the variable "result"  is

        an "int" type variable but can be assigned any of the values

        defined for it.  The names within the parentheses are  "int"

        type  constants and can be used anywhere it is legal to  use

        an "int" type constant.  The constant "win" is assigned  the

        value of 0, "tie" the value 1, "bye" the value 2, etc.

             In  use,  the variable "result" is used just  like  any

        "int" type variable would be used and can be seen by its use

        in the program.  The "enum" type of variable is intended  to

        be  used by you, the programmer, as a coding aid  since  you

        can use a constant named "mon" for control structures rather

        that  the meaningless (at least to you) value of 1.   Notice

        that  "days" is assigned the values of days of the  week  in

        the remainder of the program.  If you were to use a "switch"

        statement,  it  would  be much more meaningful  to  use  the

        labels "sun", "mon", etc, rather than the more awkward 0, 1,

        2, etc.  The remainder of the program is simple and will  be

        left to your inspection and understanding.

        PROGRAMMING EXERCISE

        1.   Write a program to count from 7 to -5 by counting down.

             Use #define statements to define the limits. (Hint, you

             will  need to use a decrementing variable in the  third

             part of the "for" loop control.

        2.   Add some print statements to MACRO.C to see the  result

             of the erroneous addition macro.

                                  Page 45