music

OSdata.com

iterative (do or for) loop

summary

    This subchapter looks at the iterative loop (do or for loop).

free computer programming text book project table of contents If you like the idea of this project, then please donate some money. more information on donating

stub section

    This subchapter is a stub section. It will be filled in with instructional material later. For now it serves the purpose of a place holder for the order of instruction.

    Professors are invited to give feedback on both the proposed contents and the propsed order of this text book. Send commentary to Milo, PO Box 1361, Tustin, California, 92781, USA.

iterative (do or for) loop

    The most basic loop or repetition structure is known as the DO LOOP. This is also called the FOR LOOP. Another name for this is the Iterative DO or Iterative loop.

    In the DO LOOP, you instruct the computer exactly how many times you want it to repeat a particular task and it does it exactly that many times (assuming no crashes or bugs).

    Please remember that the examples in this informal discussion are not from any actual programming language. These are designed to illustrate the basic principles.

    Using our average example from above, you will notice that after the first (initialization) steps (1.a and 1.b.) and before the last (final computation) step (7), that each of the pairs of steps are exactly the same. Instead of writing out each and every step, we could describe the two basic steps and put them into a DO LOOP:

    Initialize;
    BEGIN
        Subtotal := 0;
    END;
    DO five times;
    BEGIN
        Add the next number to the Subtotal;
    END;
    Finish;
    BEGIN
        Answer is Subtotal divided by 5;
    END;

    In most programming languages there is some variation of a loop count variable. The number of times to loop is established by setting the initial value of the loop count variable and setting the limit for the the number of times to repeat the DO LOOP.

    Initialize;
    BEGIN
        Subtotal := 0;
        IF there are no numbers available to average
            THEN REPORT an ERROR and STOP;
    END;
    DO Count := 1 TO 5;
    BEGIN
        Add the next number to the Subtotal;
    END;
    Finish;
    BEGIN
        Answer is Subtotal divided by Count;
    END;

    You may notice that we started the count at one rather than zero. We did this to have the DO LOOP perform exactly five repetitions with the count of numbers matching the standard counting numbers.

    You may also notice that we used the Count outside of the actual DO LOOP. Note that in many prgramming languages you can not actually use the loop count variable outside the loop (although you can usuually use it inside the DO LOOP). A common work-around is to create an extra copy of the count variable that we can use outside the DO LOOP:

    Initialize;
    BEGIN
        Subtotal := 0;
        NumberCount := 0;
        IF there are no numbers available to average
            THEN REPORT an ERROR and STOP;
    END;
    DO LoopCount := 1 TO 5;
    BEGIN
        Add the next number to the Subtotal;
        Increment (add one to) the NumberCount;
    END;
    Finish;
    BEGIN
        Answer is the Subtotal divided by the NumberCount;
    END;

    The loop count variable is considered to have a start value and a finish value. The loop count variable is often called the control variable. The starting value for the control variable is often called the initial value. The finishing value for the control variable is often called the limit value.

   “Ah, variable names.ÊLength is not a virtue in a name; clarity of expression is.ÊA global variable rarely used may deserve a long name, maxphysaddr say.ÊAn array index used on every line of a loop needn’t be named any more elaborately than i.Ê Saying index or elementnumber is more to type (or calls upon your text editor) and obscures the details of the computation.ÊWhen the variable names are huge, it’s harder to see what’s going on.ÊThis is partly a typographic issue; consider
        for(i=0 to 100)
            array[i]=0 ;
   “vs.
        for(elementnumber=0 to 100)
            array[elementnumber]=0;
   “The problem gets worse fast with real examples.ÊIndices are just notation, so treat them as such.” —Rob Pike, Notes on Programming in C, February 21, 1989

    Some programming languages will allow greater flexibility in how the loop count variable is used. Many programming languages give the choice of counting up or counting down. Computers are really good at counting down to zero. This shouldn’t matter much with modern computers (where the ability to easily read and understand someone else’s program is far more important than a nanosecond saved somewhere), but you will certainly encounter this when working on old programs from back in the days when this time difference was important.

    Most prgramming languages allow the initial value and limit value to be variables. This allows the flexibility of the program deciding these values while it is running rather thaan the programmer having to know the values in advance when the program is written. This is known as the difference between run time and compile time.

    Some programming languuages allow the step to be something other than a step up or down by one (increment and decrement). An example might be a loop that only works on odd or even numbers (the initial value might be one (1) for odd numbers and either zero (0) or two (2) for even numbers).

    In the following example, the loop would be performed a total of 10 times and each time through the loop the count would be a multiple of ten (for some reason we need multiples of ten in the work we are doing).

DO COUNT := 10 to 100 STEP UP BY 10;

    If the programming language allows for steps other than increment, the size of the step is known as the step value or the modification value. There is also the possibility that the step value can be a variable and determined at run time.

    Some programming languages allow a lot more variations, such as counting from 1 to 99 by steps of 1 and then coutning from 100 to 1,000 by steps of 100., or even more complicated versions. Because this is an informal discussion, I won’t get into those complexities here, but I wanted you to know that they can exist.

C

Ada

---