                        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 12 









                        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 13 









                        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.
         
                              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 

        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, 



                                 Page 14 









                        Chapter 3 - Program Control                        


        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 

        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 



                                 Page 15 









                        Chapter 3 - Program Control                        


        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 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 17 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.
         
                       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 



                                 Page 16 









                        Chapter 3 - Program Control                        


        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 actually 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.


        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 

