
                        Chapter 3 - Program Control


                               THE WHILE LOOP

             The  C programming language has several structures  for
        looping  and conditional branching.   We will cover them all
        in this chapter and we will begin with the while loop.   The
        while  loop continues to loop while some condition is  true.
        When   the   condition  becomes  false,   the   looping   is
        discontinued.   It therefore does just what it says it does,
        the name of the loop being very descriptive.

             Load the program WHILE.C and display it for an  example
        of  a while loop.   We begin with a comment and the  program
        name,  then  go  on  to define an integer  variable  "count"
        within the body of the program.  The variable is set to zero
        and we come to the while loop itself.  The syntax of a while
        loop is just as shown here.  The keyword "while" is followed
        by an expression of something in parentheses,  followed by a
        compound  statement  bracketed by braces.   As long  as  the
        expression in parenthesis is true, all statements within the
        braces will be executed.   In this case,  since the variable
        count  is incremented by one every time the  statements  are
        executed, it will eventually reach 6, the statement will not
        be executed,  and the loop will be terminated.   The program
        control   will   resume  at  the  statement  following   the
        statements in braces.

             We  will  cover  the compare  expression,  the  one  in
        parentheses, in the next chapter.  Until then, simply accept
        the  expressions for what you think they should do  and  you
        will probably be correct.

             Several  things must be pointed out regarding the while
        loop.   First,  if the variable count were initially set  to
        any  number greater than 5,  the statements within the  loop
        would  not be executed at all,  so it is possible to have  a
        while  loop  that  never  is  executed.   Secondly,  if  the
        variable  were  not incremented in the loop,  then  in  this
        case,  the loop would never terminate, and the program would
        never complete.   Finally, if there is only one statement to
        be executed within the loop, it does not need braces but can
        stand alone.

             Compile and run this program.

                             THE DO-WHILE LOOP

             A  variation  of the while loop is illustrated  in  the
        program DOWHILE.C,  which you should load and display.  This
        program  is nearly identical to the last one except that the
        loop  begins  with the reserved word  "do",  followed  by  a
        compound  statement  in  braces,   then  the  reserved  word


                                 Page 11









                        Chapter 3 - Program Control


        "while",  and  finally  an expression in  parentheses.   The
        statements in the braces are executed repeatedly as long  as
        the expression in parentheses is true.   When the expression
        in parentheses becomes false,  execution is terminated,  and
        control passes to the statements following this statement.

             Several  things  must  be pointed  out  regarding  this
        statement.  Since  the test is done at the end of the  loop,
        the  statements  in  the braces will always be  executed  at
        least once.   Secondly,  if "i" were not changed within  the
        loop,  the loop would never terminate, and hence the program
        would  never terminate.   Finally,  just like for the  while
        loop,  if  only  one statement will be executed  within  the
        loop,  no braces are required.  Compile and run this program
        to see if it does what you think it should do.

             It  should come as no surprise to you that these  loops
        can be nested.  That is, one loop can be included within the
        compound  statement of another loop,  and the nesting  level
        has no limit.

                                THE FOR LOOP

             The  "for" loop is really nothing new,  it is simply  a
        new  way  to describe the "while" loop.   Load and edit  the
        file  named  FORLOOP.C for an example of a  program  with  a
        "for"  loop.  The  "for" loop consists of the reserved  word
        "for" followed by a rather large expression in  parentheses.
        This expression is really composed of three fields separated
        by  semi-colons.   The  first field contains the  expression
        "index  = 0" and is an initializing field.   Any expressions
        in  this field are executed prior to the first pass  through
        the loop.   There is essentially no limit as to what can  go
        here,  but  good programming practice would require it to be
        kept simple.   Several initializing statements can be placed
        in this field, separated by commas.

             The second field,  in this case containing "index < 6",
        is  the  test which is done at the beginning  of  each  loop
        through  the program.   It can be any expression which  will
        evaluate  to a true or false.   (More will be said about the
        actual value of true and false in the next chapter.)

             The expression contained in the third field is executed
        each time the loop is executed but it is not executed  until
        after  those  statements  in the main body of the  loop  are
        executed.   This field, like the first, can also be composed
        of several operations separated by commas.

             Following  the  for()  expression  is  any  single   or
        compound statement which will be executed as the body of the


                                 Page 12









                        Chapter 3 - Program Control


        loop.   A  compound  statement  is  any  group  of  valid  C
        statements enclosed in braces.   In nearly any context in C,
        a  simple statement can be replaced by a compound  statement
        that will be treated as if it were a single statement as far
        as program control goes.  Compile and run this program.

             You  may  be  wondering why there  are  two  statements
        available that do exactly the same thing because the "while"
        and  the "for" loop do exactly the same thing.  The  "while"
        is convenient to use for a loop that you don't have any idea
        how many times the loop will be executed, and the "for" loop
        is  usually used in those cases when you are doing  a  fixed
        number  of  iterations.  The "for" loop is  also  convenient
        because  it moves all of the control information for a  loop
        into one place, between the parentheses, rather than at both
        ends  of the code.  It is your choice as to which you  would
        rather use.

                              THE IF STATEMENT

             Load  and  display the file IFELSE.C for an example  of
        our first conditional branching statement, the "if".  Notice
        first,  that there is a "for" loop with a compound statement
        as its executable part containing two "if" statements.  This
        is an example of how statements can be nested.  It should be
        clear  to  you  that each of the  "if"  statements  will  be
        executed 10 times.

             Consider the first "if" statement.   It starts with the
        keyword  "if" followed by an expression in parentheses.   If
        the expression is evaluated and found to be true, the single
        statement following the "if" is executed,  and if false, the
        following  statement  is  skipped.   Here  too,  the  single
        statement  can be replaced by a compound statement  composed
        of  several statements bounded by  braces.   The  expression
        "data  == 2" is simply asking if the value of data is  equal
        to 2,  this will be explained in detail in the next chapter.
        (Simply suffice for now that if "data = 2" were used in this
        context, it would mean a completely different thing.)

                            NOW FOR THE IF-ELSE

             The  second  "if"  is  similar to the  first  with  the
        addition  of a new reserved word,  the "else" following  the
        first  printf  statement.   This  simply says  that  if  the
        expression in the parentheses evaluates as true,  the  first
        expression  is executed,  otherwise the expression following
        the "else" is executed.   Thus,  one of the two  expressions
        will  always be executed,  whereas in the first example  the
        single expression was either executed or skipped.  Both will



                                 Page 13









                        Chapter 3 - Program Control


        find  many uses in your C programming efforts.   Compile and
        run this program to see if it does what you expect.

                           THE BREAK AND CONTINUE

             Load  the file named BREAKCON.C for an example  of  two
        new statements.  Notice that in the first "for", there is an
        if  statement that calls a break if xx equals 8.   The break
        will  jump  out of the loop you are in and  begin  executing
        statements following the loop,  effectively terminating  the
        loop.   This  is a valuable statement when you need to  jump
        out  of  a  loop  depending on the  value  of  some  results
        calculated  in the loop.   In this case,  when xx reaches 8,
        the  loop is terminated and the last value printed  will  be
        the previous value, namely 7.

             The  next  "for" loop,  contains a  continue  statement
        which  does not cause termination of the loop but jumps  out
        of the present iteration.  When the value of xx reaches 8 in
        this case,  the program will jump to the end of the loop and
        continue  executing  the loop,  effectively eliminating  the
        printf statement during the pass through the loop when xx is
        eight.   Compile and run the program to see if it does  what
        you expect.

                            THE SWITCH STATEMENT

             Load  and  display the file SWITCH.C for an example  of
        the  biggest construct yet in the C  language,  the  switch.
        The switch is not difficult, so don't let it intimidate you.
        It  begins with the keyword "switch" followed by a  variable
        in parentheses which is the switching variable, in this case
        "truck".   As many cases as desired are then enclosed within
        a pair of braces.  The reserved word "case" is used to begin
        each  case  entered followed by the value of  the  variable,
        then a colon, and the statements to be executed.

             In  this example,  if the variable "truck" contains the
        value 3 during this pass of the switch statement, the printf
        will  cause "The value is three" to be  displayed,  and  the
        "break" statement will cause us to jump out of the switch.

             Once  an  entry  point is  found,  statements  will  be
        executed until a "break" is found or until the program drops
        through  the bottom of the switch braces.   If the  variable
        has  the value 5,  the statements will begin executing where
        "case  5  :" is found,  but the first statements  found  are
        where the case 8 statements are.  These are executed and the
        break  statement  in the "case 8" portion  will  direct  the
        execution  out the bottom of the switch.   The various  case



                                 Page 14









                        Chapter 3 - Program Control


        values can be in any order and if a value is not found,  the
        default portion of the switch will be executed.

             It should be clear that any of the above constructs can
        be  nested  within  each  other  or  placed  in  succession,
        depending on the needs of the particular programming project
        at hand.

             Compile  and  run SWITCH.C to see if it does  what  you
        expect it to after this discussion.

             Load  and display the file GOTOEX.C for an example of a
        file  with some "goto" statements in it.   To use  a  "goto"
        statement,  you simply use the reserved word "goto" followed
        by the symbolic name to which you wish to jump.  The name is
        then  placed  anywhere in the program followed by  a  colon.
        You  are  not  allowed to jump into any loop,  but  you  are
        allowed to jump out of a loop.  Also, you are not allowed to
        jump out of any function into another.   These attempts will
        be flagged by your C compiler as an error if you attempt any
        of them.

             This  particular program is really a mess but it  is  a
        good example of why software writers are trying to eliminate
        the  use of the "goto" statement as much as  possible.   The
        only place in this program where it is reasonable to use the
        "goto"  is the one in line 18 where the program jumps out of
        the three nested loops in one jump.   In this case it  would
        be  rather messy to set up a variable and jump  successively
        out of all three loops but one "goto" statement gets you out
        of all three.

             Some  persons say the "goto" statement should never  be
        used  under  any circumstances, but this  is  rather  narrow
        minded  thinking.  If there is a place where a  "goto"  will
        clearly do a neater control flow than some other  construct,
        feel free to use it.  It should not be abused however, as it
        is in the rest of the program on your monitor.

             Entire  books  are written on  "gotoless"  programming,
        better known as Structured Programming.   These will be left
        to  your  study.   One  point  of reference  is  the  Visual
        Calculater described in Chapter 14 of this  tutorial.   This
        program  is  contained in four separately compiled  programs
        and  is a rather large complex program.   If you spend  some
        time studying the source code,  you will find that there  is
        not  a single "goto" statement anywhere in it.   Compile and
        run  GOTOEX.C  and study its output.   It would  be  a  good
        exercise  to rewrite it and see how much more readable it is
        when the statements are listed in order.



                                 Page 15









                        Chapter 3 - Program Control


                       FINALLY, A MEANINGFUL PROGRAM

             Load  the  file  named TEMPCONV.C for an example  of  a
        useful,  even  though somewhat limited program.   This is  a
        program  that generates a list of centigrade  and  farenheit
        temperatures  and prints a message out at the freezing point
        of water and another at the boiling point of water.

             Of particular importance is the formatting.  The header
        is  simply  several lines of comments  describing  what  the
        program  does in a manner that catches the readers attention
        and  is  still  pleasing to the  eye.  You  will  eventually
        develop your own formatting style, but this is a good way to
        start.   Also if you observe the for loop,  you will  notice
        that  all  of  the contents of the  compound  statement  are
        indented  3 spaces to the right of the "for" reserved  word,
        and  the  closing brace is lined up under the "f" in  "for".
        This  makes debugging a bit easier because the  construction
        becomes  very  obvious.   You  will  also  notice  that  the
        "printf"  statements that are in the "if" statements  within
        the  big  "for" loop are indented  three  additional  spaces
        because they are part of another construct.

             This  is  the first program in which we used more  than
        one  variable.   The three variables are simply  defined  on
        three  different lines and are used in the same manner as  a
        single variable was used in previous programs.   By defining
        them  on different lines,  we have an opportunity to  define
        each with a comment.

                      ANOTHER POOR PROGRAMMING EXAMPLE

             Recalling  UGLYFORM.C from the last chapter,  you saw a
        very  poorly  formatted program.   If you load  and  display
        DUMBCONV.C you will have an example of poor formatting which
        is  much closer to what you will find in practice.  This  is
        the same program as TEMPCONV.C with the comments removed and
        the variable names changed to remove the descriptive  aspect
        of  the names.  Although this program does exactly the  same
        as  the  last  one, it is much more difficult  to  read  and
        understand.   You should begin to develop  good  programming
        practices now.

             Compile  and  run  this program to  see  that  it  does
        exactly what the last one did.








                                 Page 16









                        Chapter 3 - Program Control


        PROGRAMMING EXERCISES

        1.  Write a program that writes your name on the monitor ten
            times.   Write this program three times, once with  each
            looping method.

        2.  Write a program that counts from one to ten, prints the
            values  on  a separate line for each,  and  includes  a
            message  of  your  choice when the count  is  3  and  a
            different message when the count is 7.











































                                 Page 17
