Search

5.5 — While statements

The while statement is the simplest of the four loops that C++ provides, and it has a definition very similar to that of an if statement:

while (expression)
    statement;

A while statement is declared using the while keyword. When a while statement is executed, the expression is evaluated. If the expression evaluates to true (non-zero), the statement executes.

However, unlike an if statement, once the statement has finished executing, control returns to the top of the while statement and the process is repeated.

Let’s take a look at a simple while loop. The following program prints all the numbers from 0 to 9:

This outputs:

0 1 2 3 4 5 6 7 8 9 done!

Let’s take a closer look at what this program is doing. First, count is initialized to 0. 0 < 10 evaluates to true, so the statement block executes. The first statement prints 0, and the second increments count to 1. Control then returns back to the top of the while statement. 1 < 10 evaluates to true, so the code block is executed again. The code block will repeatedly execute until count is 10, at which point 10 < 10 will evaluate to false, and the loop will exit.

It is possible that a while statement executes 0 times. Consider the following program:

The condition 15 < 10 immediately evaluates to false, so the while statement is skipped. The only thing this program prints is done!.

Infinite loops

On the other hand, if the expression always evaluates to true, the while loop will execute forever. This is called an infinite loop. Here is an example of an infinite loop:

Because count is never incremented in this program, count < 10 will always be true. Consequently, the loop will never terminate, and the program will print "0 0 0 0 0 ..." forever.

We can declare an intentional infinite loop like this:

The only way to exit an infinite loop is through a return statement, a break statement, an exit statement, a goto statement, an exception being thrown, or the user killing the program.

Programs that run until the user decides to stop them sometimes intentionally use an infinite loop along with a return, break, or exit statement to terminate the loop. It is common to see this kind of loop in web server applications that run continuously and service web requests.

Loop variables

Often, we want a loop to execute a certain number of times. To do this, it is common to use a loop variable, often called a counter. A loop variable is an integer variable that is declared for the sole purpose of counting how many times a loop has executed. In the examples above, the variable count is a loop variable.

Loop variables are often given simple names, such as i, j, or k. However, naming variables i, j, or k has one major problem. If you want to know where in your program a loop variable is used, and you use the search function on i, j, or k, the search function will return half your program! Many words have an i, j, or k in them. Consequently, a better idea is to use iii, jjj, or kkk as your loop variable names. Because these names are more unique, this makes searching for loop variables much easier, and helps them stand out as loop variables. An even better idea is to use "real" variable names, such as count, or a name that gives more detail about what you're counting.

It is best practice to use signed integers for loop variables. Using unsigned integers can lead to unexpected issues. Consider the following code:

Take a look at the above example and see if you can spot the error. It's not very obvious.

It turns out, this program is an infinite loop. It starts out by printing "10 9 8 7 6 5 4 3 2 1 blastoff!" as desired, but then goes off the rails, and starts counting down from 4294967295. Why? Because the loop condition count >= 0 will never be false! When count is 0, 0 >= 0 is true. Then --count is executed, and count overflows back to 4294967295. And since 4294967295 is >= 0, the program continues. Because count is unsigned, it can never be negative, and because it can never be negative, the loop won't terminate.

Rule: Always use signed integers for your loop variables.

Iteration

Each time a loop executes, it is called an iteration.

Because the loop body is typically a block, and because that block is entered and exited with each iteration, any variables declared inside the loop body are created and then destroyed with each iteration. In the following example, variable x will be created and destroyed 5 times:

For fundamental variables, this is fine. For non-fundamental variables (such as structs and classes) this may cause performance issues. Consequently, you may want to consider defining non-fundamental variables before the loop. This is another one of the cases where you might declare a variable well before its first actual use.

Note that variable count is declared outside the loop. This is necessary because we need the value to persist across iterations (not be destroyed with each iteration).

Often, we want to do something every n iterations, such as print a newline. This can easily be done by using the modulus operator on our counter:

This program produces the result:

01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50

Nested loops

It is also possible to nest loops inside of other loops. In the following example, the inner loop and outer loops each have their own counters. However, note that the loop expression for the inner loop makes use of the outer loop's counter as well!

This program prints:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Quiz

1) In the above program, why is variable inner declared inside the while block instead of immediately following the declaration of outer?

Show Solution

2) Write a program that prints out the letters a through z along with their ASCII codes. Hint: to print characters as integers, you have to use a static_cast.

Show Solution

3) Invert the nested loops example so it prints the following:

5 4 3 2 1
4 3 2 1
3 2 1
2 1
1

Show Solution

4) Now make the numbers print like this:

        1
      2 1
    3 2 1
  4 3 2 1
5 4 3 2 1

hint: Figure out how to make it print like this first:

X X X X 1
X X X 2 1
X X 3 2 1
X 4 3 2 1
5 4 3 2 1

Show Solution

5.6 -- Do while statements
Index
5.4 -- Goto statements

268 comments to 5.5 — While statements

  • I'm pretty shit at math, so - for the first time ever - I decided to put my humble programming skills to work on a real problem. Insofar as I can tell, the program is working as intended.

    So, bearing in mind that I'm working through these lessons sequentially, did I do anything wrong? Could I have written my code more efficiently or used better logic?

    Just so you know that I'm paying attention: I realize that goto statements aren't generally advisable, but I REALLY thought it was a good solution here, given the minor scope of the project, and the need to revisit the moment post-seed. I also realize that infinite loops aren't generally advisable, but again, I thought it fit the purpose.

    Please let me know if I'm mistaken. Once again, thanks @NascarDriver & @Alex, you guys are doing a service to humanity running this site.

    • - Line 13: Conditions are bools, use `while (true)`.
      - Don't use `time`, use `std::time`.
      - `123` is an int, `123u` is an unsigned int.
      - Don't use `goto`. Add another `while (true)` loop and break it if the answer is correct.
      - Line 22: No, it's not. It shouldn't even compile. Make sure you followed lesson 0.10 and 0.11. You can't initialize variables with a value read from `std::cin` without writing a wrapper function.
      - Line 11, 28: If you're using the initial value of a variable, explicitly initialize the variable to that value (0). This won't change anything in you program, but makes your code easier to follow.
      - Seed random number generators only once. If the user solves the quiz within 1 second, the same "random" numbers will be generated.

      > Could I have written my code more efficiently
      You're calculating `x * y` in every cycle of the `goto`. This is unnecessary, since neither `x` nor `y` changed their values.

  • Dhananjay Singh

    Hi, thanks for your tutorials I have a different solution to your last quiz question
    Can you just go through it and tell me your feedbacks.

    thank you both;

  • Ankit

    I had a different approach for the last question than the one given in the solution, can anyone tell me if it is a good practice to code like I have done below.

    #include<iostream>

    int main()
    {
        int outer = 1;
        while(outer<=5)
        {
            int inner = 5;
            while(inner>outer)
            {
                std::cout<< "  ";
                inner--;
            }
            while(inner>0)
                std::cout<<" "<<inner--;
            std::cout<<"\n";
            outer++;
        }
    }

    • Hi!

      Your solution is better, because it doesn't perform a comparison in ever cycle of the inner loop.

      * Initialize your variables with brace initialization.
      * Use --prefix unless you need postfix--.
      * Use single quotation marks for chars.
      * Missing return-statement.

      Please use code tags when posting code.

  • Napalm

    I had a feeling this would be wrong because of having those numbers in there. I didn't realise you could increment a char. I'll certainly remember now though so I guess I still learned :)

  • Harshitha.R

    Hello there , could anyone help me as to how this program works?
    #include <iostream>

    // Loop between 1 and 5
    int main()
    {
        int outer = 1;
        while (outer <= 5)
        {
            // loop between 1 and outer
            int inner = 1;
            while (inner <= outer)
                std::cout << inner++ << " ";

            // print a newline at the end of each row
            std::cout << "\n";
            ++outer;
        }

        return 0;
    }

  • Miquel

    Hello again!

    I finished the last quiz and had a different solution then the ones I found here.
    It works as expected, but I'd love to know if there's I could do better or any potential dangerous habits.

    Again, thanks Alex and nascardriver for all the help! I'm having a great time learning here.

    • Hello!

      If you want to, you can merge line 12 into line 9.
      Line 16 and 19 should print chars. This allows @std::cout::operator<< to use an optimized version to print (Since it doesn't have to check the text's length when it's just a char).

  • Red Lightning

    --The code in question 4, am I the only one spotting magic numbers (5)?

Leave a Comment

Put all code inside code tags: [code]your code here[/code]