Skip to content
Field Guide

While Loop

The while loop is a common feature of most programming languages. It is a pre-test loop, meaning that the statement starts with a condition, then a statement to be repeated. This means the code inside the loop will be repeated zero or more times, depending on the value of the condition. This is visualised in the following diagram.

The pre-test Loop checks the condition, then runs the loop’s body

While — when, why, and how

The while loop is a flexible way to have code repeated and will be used a lot in your programs. It should be your first thought when you want something to be repeated.

As with branching, a while loop is a form of control flow because it literally controls the flow of instructions to the CPU. See the image below for a visualisation of this. Overall, the instructions are still being processed in sequence — there are just two paths to choose from (repeating or ending the loop).

A while loop is still seen as a sequence of instructions to the CPU

When planning to use a while loop, you first need to determine the condition that will indicate if the loop should be run. This condition determines if the computer continues into the while loop’s body, or if the loop body is skipped and the sequence continues with the instructions that follow the loop. You then want to make sure that something in the loop will change the condition so that there is a definite end to the loop. This could be reading a value from the user, or re-checking which events have occurred.

At a lower level, the while loop is achieved using two jump statements:

  1. At the start of the loop, we have a conditional jump. If the condition is false, we jump to the instruction that follows the loop. Otherwise, control continues to flow in sequence to the loop’s body (the statement following the condition).
  2. At the end of the body of the loop, a jump statement is added to go back to the condition, and step 1 is repeated.

It is important to remember these actions that are performed. The while is just testing at the start, then either going into the body of the loop or jumping to the statement that follows. The value the condition evaluates to may change at any time, but it will only be checked when control is back at the top of the loop and the computer needs to determine whether to run the loop again or not.

In C

In C# the while loop starts with the while keyword followed by the condition within parenthesis. The statement to be repeated follows this, which in almost all cases will be a compound statement.

How does while work?

Let’s work through two examples: a while loop for a terminal-based program and one for a graphical application using SplashKit.

Counting with while

The following code provides a simple example of how to work with a while loop. In this program we want to output a count from 0 up to a target the user provides. To achieve this, we will need a variable for the target which will store the value the user enters. We will also need a variable to keep track of our count, indicating which value we are up to.

These steps are coded into the program below. The user is asked to enter a number, which we store in the target variable, and we create a second variable (i) that we use to count the number of times the loop runs. Before the loop, i is set to 0 as we generally count from 0 in our code.

The while loop runs while i is less than the target. Within the loop, we use the i++ assignment statement to increase the value of i. This means that the value of i will eventually be larger than or equal to the target, thereby ensuring the loop will end.

using static System.Console;
using static System.Convert;


int target;


Write("Count to: ");
target = ToInt32(ReadLine());


int i =  0;


while (i < target)
{
    WriteLine(i);
    i++;
}

Use the following images to see how this runs.

Lines 1 - 5 get the user input (in this case we'll say the user entered 10), and store it in the variable 'target' on the stack. The program counter is incremented to line 6.
On line 6, a variable named 'i' is declared and initialized to 0 on the stack. 'i' will function as our loop counter. The program counter is incremented to line 7, the start of our while loop.
The condition of our while loop is evaluated. Since 'i' (0) is less than 'target' (10), it evaluates to true. The program counter is incremented to the start of the while block (line 8).
The opening brace indicates the start of our while loop block of code. The program counter is incremented to line 9.
Line 9 outputs the value of our loop counter (i) to the terminal (in this case 0). The program counter increments to line 10.
The value of our loop counter 'i' is incremented by 1. The program counter is incremented to line 11, where it hits the closing brace, at this point it cycles back up to line 7 in order to evaluate the while condition once more to determine if the loop is to continue or not.
The while loop condition is evaluated once more. It evaluates to true because the value of 'i' (1) is still less than the value of 'target' (10), and so it will execute the block of code between the while braces once more.
Line 9 prints the value of 'i' (1) to the terminal. The program counter increases to line 10.
Line 10 increments the value of 'i' by 1. The program counter moves to line 11, then back up to line 7 to evaluate the while condition to determine whether the loop continues or ends. While the loop counter 'i' is less than the value of 'target' (10), it keeps printing the value of 'i' to the terminal, then incrementing 'i'. Let's jump ahead
Let's jump ahead to where 'i' has just been incremented to 10. So far, the numbers 0-9 have been output to the terminal. The program counter increments to lines 11, then 7 again to evaluate the while condition.
This time on line 7, 'i' is not less than 'target', and so evaluates to false. The program counter jumps to line 11, and both the while loop and the program end.

Event Loops - Dynamic graphical programs

Now let’s look at how we can use a while loop to keep a window open in SplashKit. In this case, we can use the QuitRequested method from SplashKit to find out if the user has asked to quit the program by closing the SplashKit window on their screen. QuitRequested will return false if the user has not asked to quit, so we need to loop while quit is not requested. Remember, in C# we use ! for “not”, giving us a condition !QuitRequested() for our loop.

Within the loop, we need to tell SplashKit to respond to any events the user has performed. This is achieved with the ProcessEvents() method. It reads things like key presses, mouse movements, and window closes, and retains this information so that you can access it using other methods. In this case, it will record if the user has asked to quit, and we’re accessing this information when we call QuitRequested in the condition. If you forget to add the call to ProcessEvents then you will not be able to close the window. In these cases, switch to the terminal and kill the program with ctrl-c.

using static SplashKitSDK.SplashKit;


OpenWindow("Circle Test", 400, 400);
ClearScreen(ColorWhite());


while (!QuitRequested())
{
    FillCircle(RandomColor(), Rnd(ScreenWidth()), Rnd(ScreenHeight()), Rnd(50));
    RefreshScreen();


    ProcessEvents();
}

Use the following images to see how this runs.

Lines 1 and 2 use the SplashKit library to open a new window on the user's desktop, with the title 'Circle Test' and the dimensions 400px x 400px
Line 3 clears the main window area, initializing it to the color yellow in memory
Line 4 tests if the user has requested a quit operation, and in this case, the user hasn't so the program proceeds into the body of the while loop
At line 6 the FillCircle() function creates a new circle in the main window area (in memory only) with random dimensions
The call to RefreshScreen() on line 7 then updates the window on the user's desktop with the previous operations performed on the window in memory (lines 3 and 6)
Line 8 calls ProcessEvents() which processes any events on the event queue, including looking for user quit events
The while loop condition is evaluated once more. The user hasn't requested a quit, so the while loop continues
Another random circle is created in the window in memory
The window is refreshed from memory onto the desktop, displaying the new circle
Line 8 calls ProcessEvents() which processes any events on the event queue, including looking for user quit events
The while loop condition is evaluated once more. The user hasn't requested a quit, so the while loop continues
Let's skip ahead to the 10th iteration of the loop, line 6 will update the window object in memory with the tenth circle. At this point, the user also decides to click the 'Close Window' (quit) button on the window to close it
The window is refreshed from memory onto the desktop, displaying the new circle
Now, the 'Close Window' event that was triggered previously, will be processed by the call to ProcessEvents(), which makes it available to our program
This means that when the while condition is evaluated, it will return false because the user has requested a quit. Execution moves to the end of the while loop
The loop finishes and the program ends. The window in memory will be wiped and the window on the desktop will be closed

If you have looked at sample code for most windowed programs online, you will not have seen this loop. This is what is generally known as an event loop, which the libraries usually take care of for you. That is great for productivity, but not great when you are trying to learn how this all works. With SplashKit we want you to be in control, so you need to create something like this loop to keep things going. When you move on to professional libraries, you will then have a good idea of what they are doing for you in the background.