5.1 — Control flow introduction

When a program is run, the CPU begins execution at the top of main(), executes some number of statements, and then terminates at the end of main(). The sequence of statements that the CPU executes is called the program’s path. Most of the programs you have seen so far have been straight-line programs. Straight-line programs have sequential flow -- that is, they take the same path (execute the same statements) every time they are run (even if the user input changes).

However, often this is not what we desire. For example, if we ask the user to make a selection, and the user enters an invalid choice, ideally we’d like to ask the user to make another choice. This is not possible in a straight-line program. Alternatively, there are cases where we need to do something a number of times, but we don’t know how many times at compile time. For example, if we wanted to print all of the integers from 0 to some number the user entered, we couldn’t do that until we know what number the user entered.

Fortunately, C++ provides control flow statements (also called flow control statements), which allow the programmer to change the CPU’s path through the program. There are quite a few different types of control flow statements, so we will cover them briefly here, and then in more detail throughout the rest of the chapter.


The most basic control flow statement is the halt, which tells the program to quit running immediately. In C++, a halt can be accomplished through use of the exit() function that is defined in the cstdlib header. The exit function takes an integer parameter that is returned to the operating system as an exit code, much like the return value of main().

Here is an example of using exit():


The next most basic flow control statement is the jump. A jump unconditionally causes the CPU to jump to another statement. The goto, break, and continue keywords all cause different types of jumps -- we will discuss the difference between these in upcoming sections.

Function calls also cause jump-like behavior. When a function call is executed, the CPU jumps to the top of the function being called. When the called function ends, execution returns to the statement after the function call.

Conditional branches

A conditional branch is a statement that causes the program to change the path of execution based on the value of an expression. The most basic conditional branch is an if statement, which you have seen in previous examples. Consider the following program:

This program has two possible paths. If expression evaluates to true, the program will execute A, B, and D. If expression evaluates to false, the program will execute A, C, and D. As you can see, this program is no longer a straight-line program -- its path of execution depends on the value of expression.

The switch keyword also provides a mechanism for doing conditional branching. We will cover if statements and switch statements in more detail in an upcoming section.


A loop causes the program to repeatedly execute a series of statements until a given condition is false. For example:

This program might execute as ABC, ABBC, ABBBC, ABBBBC, or even AC. Again, you can see that this program is no longer a straight-line program -- its path of execution depends on how many times (if any) the looped portion executes.

C++ provides 3 types of loops: while, do while, and for loops. C++11 added support for a new kind of loop called a for each loop. We will discuss loops at length toward the end of this chapter, except for the for each loop, which we’ll discuss a little later.


Finally, exceptions offer a mechanism for handling errors that occur in a function. If an error occurs in a function that the function cannot handle, the function can trigger an exception. This causes the CPU to jump to the nearest block of code that handles exceptions of that type.

Exception handling is a fairly advanced feature of C++, and is the only type of control flow statement that we won’t be discussing in this section. We discuss exceptions in chapter 15.


Using program flow statements, you can affect the path the CPU takes through the program and control under what conditions it will terminate. Prior to this point, the number of things you could have a program do was fairly limited. Being able to control the flow of your program makes any number of interesting things possible, such as displaying a menu repeatedly until the user makes a valid choice, printing every number between x and y, or determining the factors of a number.

Once you understand program flow, the things you can do with a C++ program really open up. No longer will you be restricted to toy programs and academic exercises -- you will be able to write programs that have real applications. This is where the real fun begins. So let’s get to it!

5.2 -- If statements
4.x -- Chapter 4 comprehensive quiz

19 comments to 5.1 — Control flow introduction

  • Weejtoen

    Thank you very much for the nice tutorial. I have been trying to learn C++ for a while now, but never found the right tutorial, untill this website!

  • Hello Hello Alex. Am from Africa in country called Kenya.Am a student and i want to be a programmer and since started learning using this site its much easier to understand C++ and am looking forward to finish learning C++and learn JAVA with your site. God Bless.

  • Jim

    This may not be the proper place to ask this, but suppose I want to pause the program for a while. Lets say 10 to 20 seconds more or less.  Is there a pause function or some way to do this without just using cout << "Press any key to continue";, in C++.

    • Jim

      Continuing from the above. Edit didn’t work for some reason. I’m looking for two methods to do this. A function to pause the program waiting for the user to hit any key to continue and another that times out after a given time.

    • Alex

      Prior to C++11, there’s no way to do this in standard C++. Different operating systems have OS-specific functionality to do this -- for example, on Windows, windows.h contains function Sleep(), which takes a parameter indicating how many milliseconds to sleep for.

      In C++11, you can do this:

  • papaz

    hey man, thanks for the series, amazing work.
    can you advice on a more detailed exercises we can use?

  • techsavvy....aye

    Typo, in "Loops" for is printed twice.

  • Todd

    I like the fact that you’ve introduced each of these powerful concepts with a hint to their potential before diving in to the syntax.

    The following independent clause confused me:

    "control jumps to the nearest block of code that has declared it is willing to catch exceptions of that type."

    Is "control jumps" a noun that "is willing to catch exceptions", or is "jumps" being used as a verb (in which case "it is" is confusing and grammatically incorrect). I would recommend rewriting this clause. I can’t tell what you’re trying to say here.

    • Alex

      I rewrote a few of the sentences to:

      Finally, exceptions offer a mechanism for handling errors that occur in a function. If an error occurs in a function that the function cannot handle, the function can trigger an exception. This causes the CPU to jump to the nearest block of code that handles exceptions of that type.

      Is that clearer?

  • FrostByte

    "Unlike more modern programming languages, such as C# or D, C++ does not provide a foreach keyword."

    This is not true. C++11 provides for-each loops! At least it should be noted there.


  • Can we use break;’s instead of exit?

  • Uri

    Hi Alex!!

    Just onted to say WOW!!

    Your C++ tutorial is AMAZING!!! this clears soooooooo many things for me…very easy to understand - without missing anything!

    So thanks alot man!

  • Jeff

    Alex, what is the difference, if any, between using a “halt”:

    As opposed to using a standard “return” type of statement:

    I’m sure I have written and compiled code before that has multiple return statements, to be executed under various conditions, within the same main(). Is there a reason to favor one type of statement over the other?

    UPDATE: I may have partially answered my own question. If exit() is called within a function other than main() does the program terminate outright rather than returning control to main()? Side-effects? Any other reasons to use, or not use, exit()?

    • exit() will cause the program to terminate immediately, regardless of where it is called.

      One thing you’ll need to be careful of when using exit is to make sure you do any necessary cleanup before the program exits. Most of the time, no explicit cleanup is needed. However, it’s probably a good idea to close any open file handles, network sockets, etc… before exiting. Note that destructors to in-scope variables will not be called before the program exits.

Leave a Comment

Put C++ code inside [code][/code] tags to use the syntax highlighter