Selection allows us to execute a statement only if a certain condition is true:

CONSEQUENT is any statement and CONDITION is any expression. Note the required parenthesis around the condition. If the value produced by the condition is non-zero, the consequent is executed, otherwise control passes to the next statement in the program. Although the condition can be any expression, it's more common to use an expression that produces a value of type bool: true ( = 1) or false ( = 0). For example, to avoid computing the square root of a negative number we write:

Selection also allows us to specify an alternative statement to execute in case the condition is false:

If the condition produces 0, the alternative is executed and the consequent is ignored. If the condition produces a non-zero value if consequent is executed and the alternative is ignored. For example:

Until now, we have been assuming that user inputs will be valid. This is a dangerous assumption. We can use selection to validate the input. If the input is invalid, we can write an error message to cerr:

Selection only allows us to choose one of two statements. What if we want to choose one of many statements? C++ does provide the switch statement:

Switch is awkward, for example forgetting a break; statement causes the subsequent cases to be executed. Also, the key (dig) must be in an enumeration or integral type.

Note the use of the string type in this example. To make this work we need to include string.h:

Another technique is to nest selection statements:

Be careful of the dreaded dangling else problem:

What happens if x = 4.5? Does the alternative go with the first condition or the second? Answer: the alternative is matched with the closest condition, so the statement prints:

Conditions are often Boolean-valued expressions, i.e., expressions that produce a value of type bool (true or false) when executed. Be careful when testing for equality. In C++ this is done using the == operator:

An innocent mistake is to use the assignment operator:

This always executes the alternative, because the assignment statement produces the value 0, which is interpreted as false.

Inequality is tested using the != operator:

Boolean combinations are formed using the || (logical or) and && (logical and) operators:

Of course short-circuit evaluation is used by these operators: the operands are evaluated from left to right until the answer is known. The remaining operands are ignored. For example, if x is 0, then the expression

produces the value false without attempting to divide 1 by 0.

What if we want to execute several statements if a condition is true? A block statement allows us to group several statements by surrounding them with curly braces:

A block is treated like a single statement. For example, assume we prompt the user for a, b, and c, the coefficients of a quadratic ax² + bx + c. Next, we calculate b² – 4ac, the discriminant:

If the discriminant is non-negative, we calculate and print the roots, otherwise we terminate the program with an error message:

Note the placement of the curly braces. Also note that no terminating semicolon is required after a block statement.

Of course declarations, such as the declarations of root1 and root2, can be placed inside blocks. The scope of a such a declaration—i.e., the region of the program where the name can be used –extends from the declaration to the terminating curly brace. For example:

A name can only be declared once within a block:

We can redefine x in an nested block. In this case the more recent declaration eclipses the older declaration. For example:

Income tax is computed on a progressive scale. There is no tax on the first $5000 of income. Tax is 10% for the next $15000 of income, 20% for the next $30000 of income, and 30% for the remaining income. Tax laws change, so let's define all these numbers as constants that can easily be changed. Our program prompts the user for an income, then uses a nested selection to compute the tax:

Here's a sample output from the program:

An interpreter is a program that:

How do we get steps 1 through 3 to repeat an indefinite number of times?

We can repeat a statement until a condition becomes false (i.e., 0) by using an unbounded iterator. C++ has two:

CONDITION is any expression, but typically it is a Boolean-valued expression. Note the required parenthesis surrounding the condition and the required semicolon following the do-statement. Of course STATEMENT can be any type of statement, including a block statement.

STATEMENT and CONDITION are executed until CONDITION produces a false or 0 value. These are called unbounded because the condition may never produce a false value, in which case the computer loops forever. (Try typing <Ctrl> c to stop the program.) If the condition is initially true, how will it ever become false? Presumably, executing the statement will eventually change some variables that the condition depends on.

The difference between do and while is that while executes its condition before its statement, but do executes its statement first, then its condition. In fact, we don't need do, because we can implement it using while:

This only matters if the initial value produced by the condition is false. The do loop will execute STATEMENT at least once.

Let's design an interpreter that:

The main feature of our interpreter is a while loop controlled by a Boolean-valued variable called more, which is initially true:

Here the full program:

Don't forget the include directives you'll need at the top of your file:

Here's a sample output produced by the program:

One problem with our interpreter is that it lies! If the user presses the space bar, return/enter key, or tab key in response to the "Press any key ... " prompt, nothing happens. This is because the extraction operator skips white space, so the line:

blocks until a non-white space character is read. How can we correct this problem?

A stream is an example of an object. We will study objects in great detail, later. For now, it suffices to know that an object encapsulates variables and functions. We can access a variable, var, encapsulated by an object, obj, using the syntax:

We can call a function, fun, encapsulated by obj using the syntax:

The basic function encapsulated by an input stream extracts a single character (including white space):

Another version takes a variable as a parameter:

Of course passing a constant to get fails:

Most streams buffer their characters, so it's possible to put an extracted character back into the input stream:

Or we can simply peek at the next character in the input stream:

This is equivalent to:

Here's a new version of the interpreter's while loop that uses cin.get():

This is a spectacular disaster! After the user enters a number, the square root is displayed, the "press any key ... " prompt is displayed, but then the user isn't given an opportunity to respond. Instead, the user is immediately prompted for another number:

If the user attempts to quit by typing q, the program enters spews prompts on the screen without pausing for any more user input! What's going on?

It's too inefficient to move one character at a time from an input device into the computer's memory, so most computers transfer blocks of characters into a hidden buffer. This is called buffering. Usually, characters are transferred from the buffer to program variables when a newline character is added to the buffer (i.e., when the user presses the Enter/Return key), but this can be implementation-dependent. For example, executing the expression:

blocks the program. The user may now type a string of characters on the keyboard:

Still nothing may happen. All of these characters have been transferred to the buffer associated with cin:

The first character is transferred into next and the program resumes execution only after a newline character enters the buffer:

In our example the input, "49", was translated into the number 49, then transferred to the variable, x, after the newline character enters the buffer:

Next, the "Press any key ... " prompt is displayed and cin.get() is executed. This transfers the newline character into the response variable. Since newline isn't 'q' or 'Q', the loop is re entered and the user is prompted for another number.

If the user types q to this prompt, then the extraction operator attempts to translate the character q into a number. Of course this fails, breaking cin. Once cin is broken, all future extractions turn into no-ops, which causes the run away behavior.

How can we fix the problem? Well, cin encapsulates a function that flushes the buffer. In C++ this is called synchronizing the buffer with the program's variables, so the function is called sync() instead of flush(). Here's our new while loop:

Of course a larger issue is what happens if the user inadvertently types a non number in response to the "Enter a number: " prompt? For example, what if the user types "nine" or "9" instead of 9? This will break cin and consequently, the program itself. Later we will see how to fix this problem.

Often, we want more control over how many times a loop must be executed. For these situations, C++ provides the for loop statement:

INIT, CONDITION, and STEP are any expressions. They are all optional, so we can leave them out if we don't need them. After executing INIT, the for loop repeatedly executes CONDITION, STATEMENT, and STEP, until CONDITION produces a 0 value. It is equivalent to:

Typically, for loops are controlled by an integer loop control variable (LCV) that keeps track of how many times the loop is executed. The LCV can be used in the statement, too.

For example, the n-th triangle number is the number of bricks required to make a staircase n steps high:

Clearly, the n-th triangle number is 0 + 1 + 2 + 3 + ... + n. We can calculate this using a for loop:

The LCV is i. Assume n = 5, we can trace the execution of the for loop to see how tri is computed:

How many ways are there to choose a basket ball team from 10 people? How many 5-card poker hands are there? How many ways are there to choose m items from n items? The formula for computing this is:

fact(k) represents the product of all integers from 1 to k = k * (k – 1) * ... * 1.

We can compute fact(n), fact(m), and fact(n – m) using three for loops:

where fact1, fact2, and fact3 are integers initialized to 1:

We choose long unsigned int as the type because factorials can become large fast. Notice that it isn't necessary to declare the LCV, i, in the second and third for loops. The final result is:

Notice that the parenthesis around the denominator are needed. Because / and * have the same precedence, these operations will be executed from left to right without the parenthesis, which would be equivalent to:

The initial conditions are complicated. If n = m or if m = 0, then choices = 1. If n < m, then choices = 0. If m = 1 or m = n – 1, then choices = n. Here's the completed program:

Here's a sample output from the program. The last input caused the program to crash because the numbers got too large. We could attempt to fix the problems by using floating point numbers, instead of integers: