Creating Loops in C++

So far, the code we have written has been able to create programs that execute a single stream of statements, and then exit.

In this lesson, we will learn about loops. Loops will allow us to repeatedly execute a block of code, until some condition within our program changes.

While Loops

The most basic form of loop is the while loop. It executes a block of code as long as a boolean expression remains true.

The basic structure of a while loop looks like this:

1while (someBoolean) DoSomething();
2

Where we need to have multiple statements executed in our loop, we can wrap them with { and }, like in the following example:

1while (someBoolean) {
2  DoSomething();
3  DoAnotherThing();
4}
5

For example, to write the numbers from 1 to 10 to the console using a while loop, we could do this:

1int Number { 1 };
2while (Number <= 10) {
3  cout << Number << endl;
4  ++Number;
5}
6

The syntax of a while loop is very similar to the if statements we have seen in the past. We have the keyword while, a boolean expression inside ( and ), and a statement to execute.

The main difference between an if and a while is that an if statement will execute once if the provided expression is true, whilst a while statement will execute continuously, as long as the provided expression remains true.

If the condition provided to a while loop is false at the point the while loop attempts to start, the code inside the block is not executed - not even once.

The following code will not log out anything:

1while (false) {
2  cout << "Can't see me!" << endl;
3}
4

1int i { 0 };
2while (i <= 5) {
3  ++i;
4}
5

Do While Loops in C++

A do while loop is very similar to a while loop, with two key differences. The first is that the syntax is slightly different - the condition comes at the end of the block:

1do {
2  // Body here
3} while (shouldLoop);
4

To log out the numbers from 1-10 using a do while loop, we could do this:

1int Number { 1 };
2do {
3  cout << Number << endl;
4  ++Number;
5} while (Number <= 10);
6

The second difference between a while and a do while is that the code inside the block of a do while loop will always be executed at least once, even if the boolean is false.

The following code will log out Hello World! one time.

1do {
2  cout << "Hello World!" << endl;
3} while (false);
4

1int i = 0;
2do {
3  i++;
4} while (i < 0);
5

For Loops in C++

The third type of loop, the for loop, is slightly more complicated.

The basic structure is:

1for  (initialise; condition; update) {
2  // Code here
3}
4

We have three components inside the ( and ) of the for loop. These are:

• Initialise - this statement is executed a single time, before our loop starts
• Condition - this is the boolean expression that indicates if our loop should continue
• Update - this code is executed at the end of each loop iteration

These three components are separated by a semicolon ;

Lets see an example of how we can use this to log out the numbers from 1 to 10:

1for (int Number { 1 }; Number <= 10; ++Number) {
2  cout << Number << endl;
3}
4

1int Number { 0 };
2for (int i { 0 }; i < 10; ++i) {
3  Number++;
4};
5

With for loops, all three components inside the ( and ) are optional - we can omit the ones we don't need.

However, we still do need to keep the semicolons, to disambiguate which components we are using.

For example, to omit the 1st and 3rd component, we could do this:

1int Number { 1 };
2for ( ; Number < 10 ; ) {
3  cout << Number << endl;
4  ++Number;
5}
6

The above is rather messy code. We should just use a while loop in that scenario, but it is possible to use a for loop. We can even remove the conditional check:

1int Number { 1 };
2for ( ; ; ) {
3  cout << Number << endl;
4  ++Number;
5}
6

This code will compile, but you may see a problem with it. We're not specifying when the loop should stop, so the loop will never stop.

Infinite Loops

Inevitably, we will make a mistake when writing a loop that causes the loop to never end. For example:

1int Number { 1 };
2while (Number <= 10) {
3  cout << Number << endl;
4  // Oops!  we forgot to increment Number
5}
6

Because the body of our loop is having no effect on the boolean expression that controls when our loop ends, this loop will not end under normal circumstances.

Number will always be <= 10. This is a fairly common scenario, called an infinite loop.

When we introduce an infinite loop, the remedy is usually just to force our program to close. For programs running in our terminal that are stuck in an infinite loop, we should still be able to close them from the title bar.

If that doesn't work, or we're creating a program that doesn't have the title bar, we can generally force our programs to close from our operating system - eg, ctrl + alt + delete in Windows, or Force Quit on Apple devices.

Nesting C++ Loops

The blocks created by our loop statements behave like any blocks we've seen, such as those associated with functions and if statements. They have their own scope, inside which we can create variables, call functions, and create other block statements.

For example, to log out the numbers from 1-10, but to treat one number differently, we could nest an if statement inside our loop:

1int Number { 1 };
2while (Number <= 10) {
3  if (Number == 5) {
4    cout << "Five!" << endl;
5  } else {
6    cout << Number << endl;
7  }
8  ++Number;
9}
10

We can also nest loops within loops. For example:

1for (int i = 0; i < 40; i+=20) {
2  for (int j = 10; j <= 30; j++) {
3    cout << i + j << " ";
4  }
5  cout << endl;
6}
7

In the above example, we have an inner loop that logs out 20 numbers, with a space after each one. We then have an outer loop that calls that inner loop twice, and logs out a new line each time.

In the next lesson, covering the modulus operator, we will see a slightly simpler way of implementing this behavior.

There is nothing special about the use of the variable names i and j. There is just a general convention that, if a better variable name is not available, we use the name i for the integer that controls the iteration count of loops. If i is not available, developers will often use j instead.

The continue Statement in C++ Loops

We can use the continue keyword within the body of a loop to give us more control over its execution. When we call continue, the loop will skip over the remaining code for this iteration, and continue onwards to the next.

If the condition that controls the loop is no longer true, the loop will instead end.

The continue word is most typically used in a conditional block within our loop. For example, to log the numbers from 1-10, whilst skipping over 5, we could write this code:

1int Number { 0 };
2while (Number < 10) {
3  ++Number;
4  if (Number == 5) continue;
5  cout << Number << endl;
6}
7

1int Number { 0 };
2for (int i = 0; i < 10; i++) {
3  if (i == 5) continue;
4  Number++;
5};
6

The break Statement in C++ Loops

The break keyword can be called within the body of a loop, in order to exit the loop entirely, and to stop iterating. Similar to how continue was used, break is generally most useful within a conditional in our loop.

For example, to limit the iterations of a while loop to 100, regardless of whether the condition is true, we could do this:

1int RemainingIterations { 100 };
2
3while (true) {
4  DoSomething();
5
6  --RemainingIterations;
7  if (RemainingIterations <= 0) break;
8}
9

The previous code demonstrates a pretty common technique for designing functions. This is especially useful when we don't know when the loop will end - for example, it might continue until the user presses a button.

Often, we will solve these problems by intentionally creating an infinite loop. We can do this by using a boolean expression that will always be true, such as the literal value true:

1while (true) {
2  doWork();
3}
4

Then we can call break from within the loop when we want it to end. This gives us an easy way of implementing some additional behaviour before the loop ends:

1while (true) {
2  doWork();
3  if (isComplete) {
4    cout << "Task Complete!";
5    break;
6  }
7}
8

1int i { 0 };
2while (i >= 0) {
3  if (i == 5) break;
4  i++;
5};
6

Returning from Loops

Within a loop, we can also use a return statement. This will break from the loop, but also return from the function where the loop was running.

In this example, we show an implication of this:

1int main() {
2  while (true) {
3    // Close program if user pressed quit
4    if (didUserPressExitButton()) return 0;
5
6    // Otherwise, continue running
7    RenderFrame();
8  }
9  SayGoodbye();
10}
11

In the above function, SayGoodbye() will never be called. This highlights a subtle difference between return and break when used in the body of a loop. break will leave the loop - return will leave both the loop and the function.

This means that, if our function has some additional code that we always want to run after the loop ends, we should use break instead.

1int main() {
2  while (true) {
3    // Close program if user pressed quit
4    if (didUserPressExitButton()) break;
5
6    // Otherwise, continue running
7    RenderFrame();
8  }
9  SayGoodbye();
10}
11