Lesson 06: Loops

while (1) {
    sensorValue = readSensorData();
    updateOutput(sensorValue);
}

This loop continuously reads sensor data and updates the system output accordingly, ensuring that the embedded controller remains active and responsive to sensor changes.

while (1) {
    if (receiveMessage()) {
        processMessage(message);
    }
}

This loop continuously monitors for incoming network messages. When a message is received, it is processed and the appropriate actions are taken.

while (1) {
    checkSystemResources();
    if (resourcesLow()) {
        takeCorrectiveActions();
    }
}

This loop continuously monitors system resources and takes corrective actions if resources are running low.

while (1) {
    displayMenu();
    handleUserInput();
    performSelectedAction();
}

This loop presents a menu, accepts user input, and executes the corresponding action. It continues until the user chooses to exit the program.

while (1) {
    updateGameState();
    renderGraphics();
    handleUserInput();
}

This loop continuously updates the game state, renders the game graphics, and handles player input, ensuring a smooth and responsive gaming experience.

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.

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.

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.

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

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 easier to forget the update expression in the while and do-while loop than in the for loop.

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 f = 2;

while(f != 3.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 != 3.0) never becomes false. To fix this problem, write the condition as (f <= 3.0).

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 the while condition. We know the 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 i inside the while loop. As a result, it will go on executing indefinitely.

The term "Alderson loop" is a slang or jargon term for an infinite loop in C or C++ where an exit condition is available but inaccessible in the current code implementation. This typically occurs due to a programmer's error that prevents the loop from terminating properly.

Alderson loops are often encountered in user interface (UI) code, where they can cause modal dialog boxes or other UI elements to remain permanently visible, blocking user interaction and rendering the program unresponsive. These loops can be particularly frustrating to debug as the correct exit condition is not utilized correctly.

To identify Alderson loops, programmers should carefully examine the loop logic and look for potential errors that could prevent the loop from terminating. Common causes of Alderson loops include:

1. Missing or Incorrect Termination Condition: The loop may lack a proper exit condition, or the condition may not be evaluated correctly, preventing the loop from ever ending.
2. Invalid Loop Updates: The loop may update variables or data structures in a way that never allows the exit condition to become true, effectively trapping the loop in an endless cycle.
3. Condition Overrides: Other parts of the code may override the loop's exit condition, preventing it from taking effect and causing the loop to continue indefinitely.
4. Error Handling Issues: Improper error handling mechanisms may prevent the loop from exiting when errors occur, leading to an infinite loop situation.
5. User Input Issues: In UI code, invalid user input or unexpected input values may not be handled correctly, causing the loop to get stuck in an endless cycle.

To avoid Alderson loops, programmers should adhere to sound coding practices, thoroughly review their code for potential errors, and employ rigorous testing and debugging techniques. Additionally, using proper error-handling mechanisms and validating user input can help prevent these loops from occurring in the first place.

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

int i = 0; while (i < 10) {
printf("%d\n", I);
i++;
if (i == 5) {
i = 0; // Condition override
}
}

In this example, the statement i = 0; inside the loop overrides the loop's exit condition. This prevents the loop from terminating when i reaches 5, causing it to continue indefinitely.

int i = 0;
while (i < 10) {
printf("%d\n", I);
i++;
if (openFile("data.txt") != 0) {
continue; // Error handling issue
}
// Process data from the file
}

In this example, the error handling mechanism using continue; is flawed. When openFile() fails, the loop skips to the next iteration instead of terminating. This causes the loop to continue executing indefinitely, even though the file could not be opened.

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();
}