Lesson 06: Loops

Impossible termination condition

An example for loop in C:

unsigned int i;
for (i = 1; i != 0; i++) {
    // loop code
}

It appears that this will go on indefinitely, but in fact the value of i will eventually reach the maximum value storable in an unsigned int and adding 1 to that number will wrap-around to 0, breaking the loop. The actual limit of i depends on the details of the system and compiler used. With arbitrary-precision arithmetic, this loop would continue until the computer's memory could no longer hold i. If i was a signed integer, rather than an unsigned integer, overflow would be undefined. In this case, the compiler could optimize the code into an infinite loop.

Mathematical errors

Here is one example of an infinite loop in C:

int x;
while (x < 5) {
    x = 1;
    x = x + 1;
}

This creates a situation where x will never be greater than 5, since at the start of the loop code x is given the value of 1, thus, the loop will always end in 2 and the loop will never break. This could be fixed by moving the x = 1 instruction outside the loop. Essentially what this infinite loop does is to instruct a computer to keep on adding 1 to 1 until 5 is reached. Since 1 + 1 always equals 2, this will never happen.

Assignment Operator in Condition Expression

Another common mistake that leads to an infinite loop is to use the assignment operator (=) where the equality operator is needed (==). For example, here is a snippet in C:

#include <stdio.h>

int main(void)
{
    int a = 0;
    while (a < 10) {
        printf("%d\n", a);
        if (a = 5)
            printf("a equals 5!\n");
        a++;
    }
    return 0;
}

The expected output is the numbers 0 through 9, with an interjected "a equals 5" between 5 and 6. However, in the line "if (a = 5)" above, the programmer has confused the = (assignment) operator with the == (equality test) operator. Instead, this will assign the value of 5 to a at this point in the program. Thus, a will never be able to advance to 10, and this loop cannot terminate.

Variable handling errors

Unexpected behavior in evaluating the terminating condition can also cause this problem. Here is an example (in C):

float x = 0.1;
while (x != 1.1) {
    printf("x = %f\n", x);
    x += 0.1;
}

On some systems, this loop will execute ten times as expected, but on other systems, it will never terminate. The problem is that the loop terminating condition (x != 1.1) tests for exact equality of two floating-point values, and the way floating-point values are represented in many computers will make this test fail because they cannot represent the value 0.1 exactly, thus introducing rounding errors on each increment (the x += 0.1 statement).

Forget to Update Control Variable

int i = 1;

while(i < 10) {
    printf("%d\n", i);
}

Here we are not updating the value of i. So after each iteration, the value of i remains the same. As a result, the condition (i < 10) will always be true. For the loop to work correctly add i++;, just after the printf() statement.

Always remember, it is easy to forget update expression in while and do-while loop, than in the for loop.

Condition Never Be Ture

short int i;

for (i = 32765; i < 32768; i++) {
    printf("%d\n", i);
}

This loop is an infinite loop. Here is why? According to the condition, the loop will execute until (i < 32768). Initially, the value of i is 32765 and after each iteration, its value is incremented by the update expression (i++).  But the value of short int type ranges from -32768 to 32767. If you try to increment the value of i beyond 32767, it goes on the negative side and this process keeps repeating indefinitely. Hence the condition (i < 32768) will always be true.

Float-Pointer Number

float f = 2;

while(f != 31.0)
{
    printf("%f\n", f);
    f += 0.1;
}

This loop is infinite because computers represent floating-point numbers as approximate numbers, so 3.0 may be stored as 2.999999 or 3.00001. So the condition (f != 31.0) never becomes false. To fix this problem write the condition as (f <= 31.0).

Semicolon at Wrong Place

int i = 0;

while(i <= 5);
    printf("%d\n", i);

This loop will produce no output and will go on executing indefinitely. Take a closer look and notice the semicolon (;) at the end of while condition. We know semicolon (;) after the condition is a null statement. So the loop is equivalent to the following:

int i = 0;

while(i <= 5) {
    ;   // a null statement
}

printf("%d\n", i);

We can now clearly see that we are not updating the value if i inside the while loop. As a result, it will go on executing indefinitely.

Alderson loop

Alderson loop is a rare slang or jargon term for an infinite loop where there is an exit condition available, but inaccessible in the current implementation of the code, typically due to a programmer's error. These are most common and visible while debugging user interface code.

The following C code example of an Alderson loop, where the program is supposed to sum numbers given by the user until zero is given, but where the programmer has used the wrong operator:

sum = 0;
while (true) {
    printf("Input a number to add to the sum or 0 to quit");
    i = getUserInput();
    if (i * 0) {    // if i times 0 is true, add i to the sum.
                    // Note: ZERO means FALSE, Non-Zero means TRUE. "i * 0" is ZERO (FALSE)!
        sum += i;   // sum never changes because (i * 0) is 0 for any i;
                    // it would change if we had != in the condition instead of *
    }
    if (sum > 100) {
        break;     // terminate the loop; exit condition exists but is never reached because sum is never added to
    }
}

Infinite Recursion

Infinite recursion is a special case of an infinite loop that is caused by recursion. The following example in C returns a stack overflow error:

void test1()
{
    test1();
}

int main()
{
    test1();
}