In the programs we have written so far, the statements in the program have been executed in sequence, from the start of the program to the end, omitting sections of "if" and "switch" constructs which have not been selected. The real power of computers comes from their ability to execute given sets of statements many times.
The repetition may be required for several reasons.
To repeat sets of instructions there are three main loop constructs in C.
A "while" loop repeats a given set of instructions until a given condition holds. The notation is as follows.
int number = 10;
while ( number >= 0 ) {
printf( "Value of number is %d\n", number );
number--;
} /* end while number >= 0 */
printf( "Loop ended\n" );
The condition to be tested is contained in parentheses (round brackets) after the word "while", and the body of the loop is in curly braces after the condition. There is no semi-colon after the closing curly brace.
The sequence of operations in the loop (after the initialisation of the value of "number" to 10, for example) is
The test is TRUE to continue the loop, FALSE to leave it. The test occurs before the loop is executed; the loop may not be executed at all if the test result is FALSE the very first time that it is encountered. The pattern of execution is thus
or
or
and so on. The last test on each line must have delivered the result FALSE; earlier tests must have delivered the result TRUE.
When the loop finishes, control passes to the next instruction in the program, following the closing curly brace of the loop.
To execute a loop for an integer variable "number" taking the values 1, 2, ..., 10 you may use any one of the following four possible "while" loop constructions.
Version 1
int number = 1;
while ( number <= 10 ) {
....;
number++;
}
Version 2
int number = 0;
while ( number < 10 ) {
number++;
....;
}
Version 3
int number = 0;
while ( number++ < 10 ) {
....;
}
Version 4
int number = 0;
while ( ++number <= 10 ) {
....;
}
In the first two examples, it is immaterial whether you write "number++;" or "++number;"; to increment to value of "number" either of these will do. In the third and fourth examples, you must use "++" as shown.
number < 10
and not as
number <= 9
The numeric denotations (actual numeric values) appearing in your program should be exactly the numbers you would talk about in describing what the program is required to do. In this case, the value 9 should not appear. If you are converting seconds to minutes and hours, the value 59 should not appear, only the value 60. The Ceilidh automatic marking system checks program features such as this.
#define repeats 10
main () {
....
while( number < repeats ) {
....
} /* end the loop */
} /* end main program */
The Ceilidh marking system checks that values other than, for example "0" and "1" do not appear in the body of the program, and appear exactly once in a "const" declaration. My examples in the notes may not follow this rule.
To add together the sequence
until the terms we are adding together are smaller than 0.00001 the program might be as follows.
/* We need float variables */
float term = 1.0, total = 0.0;
while ( term > 0.00001 ) {
/* Add the next term to the total */
total += term;
/* Halve the term */
term /= 2.0;
} /* end while term > 0.00001 loop */
printf( "Total %d\n", total );
The value of "term" is halved each time round the loop; each of these values is added to the total.
To read positive integer numbers in, terminated by a zero, and print the biggest one.
int next_number = 1, biggest = 0;
while ( next_number != 0 ) {
scanf( "%d", &next_number );
if ( biggest < next_number ) {
biggest = next_number;
}
} /* end while next_number non-zero */
printf( "Biggest was %d\n", biggest );
Note that the terminating zero is still processed by the statements in the second part of the loop. In this example, it will have no effect on the final result. If we were counting how many positive numbers we had read, we would have to be careful not to include the terminating zero.
If we were printing the square of each number read in, we would probably not want to print the square of the terminating zero. We would then need
int next_number = 1, biggest = 0;
while ( next_number != 0 ) {
scanf( "%d", &next_number );
if ( next_number != 0 ) {
if ( biggest < next_number ) {
biggest = next_number;
} /* end of "if giggest < ..." */
} /* end of the "if next != 0" */
} /* end while next_number non-zero */
printf( "Biggest was %d\n", biggest );
Note the following possible alternative coding, which has the drawback that the input instruction has to be repeated.
int next_number, biggest = 0;
scanf( "%d", &next_number );
while ( next_number != 0 ) {
if ( biggest < next_number ) {
biggest = next_number;
}
scanf( "%d", &next_number );
} /* end while next_number non-zero */
printf( "Biggest was %d\n", biggest );
Within the loop, we read the next number at the end of the loop. We must read the very first number before we enter the loop. We show a better solution to this problem later in this chapter.
The "while" loops above performed the test first, and then executed the loop. Sometimes you may wish to test at the end of the loop, after the execution of the statements in the body of the loop (and hence to execute the loop body always at least once). In C we use what is referred to as a "do" loop, written as follows.
int number = 1;
do {
....;
number++;
} while ( number <= 10 );
In this case the value of "number" would be 1 the first time round the loop, and 10 the last time.
The condition (exactly as in a "while" loop) is still contained in round brackets, and is still TRUE to continue with another execution of the loop body, and FALSE to leave the loop. Remember that there is a semi-colon after the condition, terminating the whole statement. We have one more semi-colon overall than the equivalent "while" loop.
The pattern of execution in this case can be summarised as follows.
The code in the above programming example could also be written
int number = 1;
do {
....;
} while ( ++number <= 10 );
This is the form of combined "increment and test" that most C programmers would use. The "++" must, of course, be in front of the "number" in this case.
It is generally safer to test at the start of a loop; "while" loops are generally safer and more common than "do" loops.
To read in positive numbers until a zero is encountered, and print the biggest one.
int next_number, biggest = 0;
do {
scanf( "%d", &next_number );
if ( biggest < next_number ) {
biggest = next_number;
}
} while ( next_number != 0 );
printf( "Biggest %d\n", biggest );
We may wish to abandon the program from within the body of the loop if some error condition occurs.
int next_number;
do {
scanf( "%d", &next_number );
if ( next_number < 0 ) {
printf( "Error, negative number\n" );
printf( "Value %d\n", next_number );
exit( 0 );
}
.. process the number ..
.. which must be >= 0 ..
} while ( next_number > 0 );
You can use the comma operator in the condition and write statements such as
int this_one = 10, that_one = 0;
while ( this_one--, that_one++, this_one > that_one ) {
....;
} /* while this_one > that_one */
At the start of the loop we decrement "this_one", then increment "that_one", and then test whether "this_one > that_one" before proceeding with the body of the loop.
It would perhaps be clearer to lay this out as
int this_one = 10, that_one = 0;
while (
this_one--,
that_one++,
this_one > that_one
) {
....;
} /* while this_one > that_one */
This shows each of the statements and tests on separate lines for clarity.
This type of construction in which the "while" condition involves several statements, effectively gives us a loop which exits in the middle. A simple "while" loop tests and exits at the top, a simple "do ... while" loop tests and exits at the bottom, and a "while" loop with commas tests and exits in the middle of the loop.
The cleanest way to, for example, read integer values until a zero is encountered, is to use the comma operator in the following construct.
while (
scanf( "%d", &next_number ),
next_number != 0
) {
....
} /* end while next value non-zero */
With this program structure, the terminating zero is not processed; this is generally what we require.
Note the layout of the program; we treat parentheses rather like curly braces. If a matching opening and closing parentheses fit onto one line, that is fine. If they do not, then they should line up with each other and be indented in the same way as curly braces. The Ceilidh automatic marking system checks that program layout conforms to this pattern.
There is a third type of loop in C, called a "for" loop. It is written as follows.
int counter, number;
for ( counter = 0; counter < 10; counter++ ) {
....;
}
for ( number = 10; number > 0; number-- ) {
....;
}
#define e 0.00001
float term;
for ( term = 1.0; term > e; term *= 0.5 ) {
....;
}
The general form of a "for" loop is
for ( initialise; test; execute after loop ) {
....;
}
The initialise statement is carried out once only, at the start of the very first time that the loop is entered. The test is executed before each execution of the body of the loop. The first time will be immediately after the initialisation, and hence there will be perhaps no executions of the loop body if the test fails at this stage. The third expression is a statement executed after every execution of the loop body, before the next test.
The sequence is now
Again note that the increments in the examples above could be written with the "++" before or after the variable identifier; in this case it does not matter.
One of the important advantages of a "for" loop is its readability. All of the essential loop control is grouped together at the top of the loop. We can see at a glance the initial values which are set up, the test to be satisfied for loop exit, and the main variable increments. You should make maximum use of this readability.
The "for" loop could be written as a "while" loop in the form
initialise;
....
while ( test ) {
....;
incr;
}
In this layout, the loop control is not so clearly seen.
Defaults are obvious; any or all of the three control statements can be omitted. The construct
for ( ; ; ) {
....;
}
gives no initialisation, assumes a TRUE test result, and performs no incrementing.
You may find the comma operator useful again, particularly in the initialisation and increment parts of the loop control.
for (
this = 10, that = 0;
this > that;
this--, that++
) {
....;
}
Loops may, of course, be nested to any depth in any combination as required.
int month, year;
for ( year = 1900; year < 2000; year++ ) {
for ( month = 0; month < 12; month++ ) {
....; /* execute 1200 times ... */
} /* end month loop for each year */
} /* end year loop */
The loop executes with "month" and "year" taking the pairs of values [1900,0], [1900,1], [1900,2], ..., [1900,11], [1901,0], [1901,1], ..., [1901,11], ..., [1999,11] in turn in that order.
In any of the above loops, the special statement "break" causes the loop to be abandoned, and execution continues following the closing curly brace.
while ( i > 0 ) {
....;
if ( j == .... ) {
break; /* abandon the loop */
}
....;
} /* end of the loop body */
printf( "continues here ...\n" );
The program continues after the end of the loop.
Within a nested loop, "break" causes the innermost loop to be abandoned.
In any of the above loops, the statement "continue" causes the rest of the current round of the loop to be skipped, and
We wish to write a loop processing integer values which we have read in. If the value we have read is negative, we wish to print an error message and abandon the loop. If the value read is great than 100, we wish to ignore it and continue to the next value in the data. If the value is zero, we wish to terminate the loop.
while ( scanf( "%d", &value ) == 1 && value != 0 ) {
if ( value < 0 ) {
printf( "Illegal value\n" );
break;
/* Abandon the loop */
}
if ( value > 100 ) {
printf( "Invalid value\n" );
continue;
/* Skip to start loop again */
}
/* Process the value read */
/* guaranteed between 1 and 100 */
....;
....;
} /* end while value != 0 */
It is good practice to comment the end closing curly brace of any loop which extends over more than a few lines. The Ceilidh system expects a comment after every closing brace which appears more than 10 lines from its opening curly brace.
If there is only a single statement in the loop body, the curly braces are not obligatory in C. It is however recommended that you always use them.
You may find examples of programs in which the complete work of a loop is performed within the parentheses of the test; such a loop may have an empty body.
while (
total += term,
term *= 0.5,
term > 0.00001
) {
;
}
This is quite legal; it may not be clear to a reader at first glance exactly what is happening.
Read positive "float" values from the input, and print their sum, how many numbers were read, the largest value and the smallest value.
int count = 0;
float maximum = 0.0, minimum = 1e6;
float total = 0.0, number;
printf( "Type positive values ended by zero or negative: " );
while ( scanf( "%f", &number ) == 1 && number > 0 ) {
/* add numbers together */
total += number;
/* check minimum so far */
if ( minimum > number ) {
minimum = number;
}
/* check maximum */
if ( maximum < number ) {
maximum = number;
}
/* count numbers */
count++;
} /* while number > 0 */
printf( "tot %d, count %d\n", total, count );
printf( "min %d, max %d\n", minimum, maximum );
Be careful if you wish to print the average of the numbers, and use
if ( count > 0 ) {
printf( "Ave %d\n", total / count );
} else {
printf( "No data to average\n" );
} /* end if count > 0 */
You must ensure that you can never attempt a division by zero. Wherever there is a division sign in a program you must be able to prove that the denominator cannot be zero.
To sum the square of all the integer values from 1 squared up to 99 squared.
int next_val, sum = 0;
/* add squares up to 99 squared */
for ( next_val = 1; next_val < 100; next_val++ ) {
sum += next_val * next_val;
}
printf( "Sum %d\n", sum );
To print (in decimal) the decreasing powers of 2 (1, 1/2, 1/4, 1/8, ...) you would write:
int count = 1;
float x = 1.0;
while ( x > 0.0001 ) {
printf( "Count %3d, x %10.4f\n", count, x );
x *= 0.5;
count++;
}
It may be clearer to write
int count = 1;
float x;
for ( x = 1.0; x > 0.0001; x *= 0.5 ) {
printf( "Count %3d, x %10.4f\n", count, x );
count++;
}
To read text until a full stop (period) is encountered, and to count the number of occurrences of the letter "e", you could write:
char ch;
int count = 0;
while (
scanf( "%c", &ch ) == 1
&& ch != '.'
) {
if ( ch == 'e' ) {
count++;
}
} /* end while ch != '.' */
printf( "There were %d letter e's\n", count );
To read a series of integers, terminated by a zero, and print how many times an integer was larger than its predecessor, and how many times it was smaller. Ignore the terminating zero.
int next, previous;
int bigger = 0, smaller = 0;
/* Set up the first value */
scanf( "%d", &previous );
/* Read data up to a zero */
while ( scanf( "%d", &next ) == 1 ) {
/* Was it bigger than the previous? */
if ( next > previous ) {
bigger++;
}
/* Was it smaller? */
if ( next < previous ) {
smaller++;
}
/* Store this value for next loop */
previous = next;
}
printf( "Bigger %d\n", bigger );
printf( "Smaller %d\n", smaller );
The exercises in this unit are marked partly on dynamic correctness, partly on typographic layout, partly on features (see earlier units for details of all of these), and may now have two new sub-headings, Complexity and Structure.
The complexity marker compares the complexity of the structure of your solution (the number of conditional, the number of loop,s, the depth of the loops, etc) with the teacher's model solution. Your program should not differ too far from the teacher's.
The structure marker looks for program weaknesses such as variables declared and not used, variables with values assigned but not used, and other points such as those revealed by using the verbose compilation option.
Copyright Eric Foxley 1996
Notes converted from troff to HTML by an Eric Foxley shell script, email errors to me!