Section 1.4. Control Structures


1.4. Control Structures

Statements execute sequentially: The first statement in a function is executed first, followed by the second, and so on. Of course, few programsincluding the one we'll need to write to solve our bookstore problemcan be written using only sequential execution. Instead, programming languages provide various control structures that allow for more complicated execution paths. This section will take a brief look at some of the control structures provided by C++. Chapter 6 covers statements in detail.

Exercises Section 1.3

Exercise 1.7:

Compile a program that has incorrectly nested comments.

Exercise 1.8:

Indicate which, if any, of the following output statements, are legal.

    std::cout << "/*";    std::cout << "*/";    std::cout << /* "*/" */; 

After you've predicted what will happen, test your answer by compiling a program with these three statements. Correct any errors you encounter.


1.4.1. The while Statement

A while statement provides for iterative execution. We could use a while to write a program to sum the numbers from 1 through 10 inclusive as follows:

     #include <iostream>     int main()     {         int sum = 0, val = 1;         // keep executing the while until val is greater than 10         while (val <= 10) {             sum += val;  // assigns sum + val to sum             ++val;       // add 1 to val         }         std::cout << "Sum of 1 to 10 inclusive is "                   << sum << std::endl;         return 0;     } 

This program when compiled and executed will print:

    Sum of 1 to 10 inclusive is 55 

As before, we begin by including the iostream header and define a main function. Inside main we define two int variables: sum, which will hold our summation, and val, which will represent each of the values from 1 through 10. We give sum an initial value of zero and start val off with the value one.

The important part is the while statement. A while has the form

    while (condition) while_body_statement; 

A while executes by (repeatedly) testing the condition and executing the associated while_body_statement until the condition is false.

A condition is an expression that is evaluated so that its result can be tested. If the resulting value is nonzero, then the condition is true; if the value is zero then the condition is false.

If the condition is true (the expression evaluates to a value other than zero) then while_body_statement is executed. After executing while_body_statement, the condition is tested again. If condition remains true, then the while_body_statement is again executed. The while continues, alternatively testing the condition and executing while_body_statement until the condition is false.

In this program, the while statement is:

     // keep executing the while until val is greater than 10     while (val <= 10) {         sum += val; // assigns sum + val to sum         ++val; // add 1 to val     } 

The condition in the while uses the less-than-or-equal operator (the <= operator) to compare the current value of val and 10. As long as val is less than or equal to 10, we execute the body of the while. In this case, the body of the while is a block containing two statements:

     {         sum += val; // assigns sum + val to sum         ++val; // add 1 to val     } 

A block is a sequence of statements enclosed by curly braces. In C++, a block may be used wherever a statement is expected. The first statement in the block uses the compound assignment operator, (the += operator). This operator adds its right-hand operand to its left-hand operand. It has the same effect as writing an addition and an assignment:

     sum = sum + val; // assign sum + val to sum 

Thus, the first statement adds the value of val to the current value of sum and stores the result back into sum.

The next statement

     ++val; // add 1 to val 

uses the prefix increment operator (the ++ operator). The increment operator adds one to its operand. Writing ++val is the same as writing val = val + 1.

After executing the while body we again execute the condition in the while. If the (now incremented) value of val is still less than or equal to 10, then the body of the while is executed again. The loop continues, testing the condition and executing the body, until val is no longer less than or equal to 10.

Once val is greater than 10, we fall out of the while loop and execute the statement following the while. In this case, that statement prints our output, followed by the return, which completes our main program.

Key Concept: Indentation and Formatting of C++ Programs

C++ programs are largely free-format, meaning that the positioning of curly braces, indentation, comments, and newlines usually has no effect on the meaning of our programs. For example, the curly brace that denotes the beginning of the body of main could be on the same line as main, positioned as we have done, at the beginning of the next line, or placed anywhere we'd like. The only requirement is that it be the first nonblank, noncomment character that the compiler sees after the close parenthesis that concludes main's parameter list.

Although we are largely free to format programs as we wish, the choices we make affect the readability of our programs. We could, for example, have written main on a single, long line. Such a definition, although legal, would be hard to read.

Endless debates occur as to the right way to format C or C++ programs. Our belief is that there is no single correct style but that there is value in consistency. We tend to put the curly braces that delimit functions on their own lines. We tend to indent compound input or output expressions so that the operators line up, as we did with the statement that wrote the output in the main function on page 6. Other indentation conventions will become clear as our programs become more complex.

The important thing to keep in mind is that other ways to format programs are possible. When choosing a formatting style, think about how it affects readability and comprehension. Once you've chosen a style, use it consistently.


1.4.2. The for Statement

In our while loop, we used the variable val to control how many times we iterated through the loop. On each pass through the while, the value of val was tested and then in the body the value of val was incremented.

The use of a variable like val to control a loop happens so often that the language defines a second control structure, called a for statement, that abbreviates the code that manages the loop variable. We could rewrite the program to sum the numbers from 1 through 10 using a for loop as follows:

     #include <iostream>     int main()     {         int sum = 0;         // sum values from 1 up to 10 inclusive         for (int val = 1; val <= 10; ++val)             sum += val; // equivalent to sum = sum + val         std::cout << "Sum of 1 to 10 inclusive is "                   << sum << std::endl;         return 0;     } 

Prior to the for loop, we define sum, which we set to zero. The variable val is used only inside the iteration and is defined as part of the for statement itself. The for statement

     for (int val = 1; val <= 10; ++val)         sum += val; // equivalent to sum = sum + val 

has two parts: the for header and the for body. The header controls how often the body is executed. The header itself consists of three parts: an init-statement, a condition, and an expression. In this case, the init-statement

     int val = 1; 

defines an int object named val and gives it an initial value of one. The initstatement is performed only once, on entry to the for. The condition

     val <= 10 

which compares the current value in val to 10, is tested each time through the loop. As long as val is less than or equal to 10, we execute the for body. Only after executing the body is the expression executed. In this for, the expression uses the prefix increment operator, which as we know adds one to the value of val. After executing the expression, the for retests the condition. If the new value of val is still less than or equal to 10, then the for loop body is executed and val is incremented again. Execution continues until the condition fails.

In this loop, the for body performs the summation

   sum += val; // equivalent to sum = sum + val 

The body uses the compound assignment operator to add the current value of val to sum, storing the result back into sum.

To recap, the overall execution flow of this for is:

  1. Create val and initialize it to 1.

  2. Test whether val is less than or equal to 10.

  3. If val is less than or equal to 10, execute the for body, which adds val to sum. If val is not less than or equal to 10, then break out of the loop and continue execution with the first statement following the for body.

  4. Increment val.

  5. Repeat the test in step 2, continuing with the remaining steps as long as the condition is true.

When we exit the for loop, the variable val is no longer accessible. It is not possible to use val after this loop terminates. However, not all compilers enforce this requirement.


In pre-Standard C++ names defined in a for header were accessible outside the for itself. This change in the language definition can surprise people accustomed to using an older compiler when they instead use a compiler that adheres to the standard.


Compilation Revisited

Part of the compiler's job is to look for errors in the program text. A compiler cannot detect whether the meaning of a program is correct, but it can detect errors in the form of the program. The following are the most common kinds of errors a compiler will detect.

  1. Syntax errors. The programmer has made a grammatical error in the C++ language. The following program illustrates common syntax errors; each comment describes the error on the following line:

                          // error: missing ')' in parameter list for main        int main ( {                      // error: used colon, not a semicolon after endl            std::cout << "Read each file." << std::endl:                      // error: missing quotes around string literal            std::cout << Update master. << std::endl;                      // ok: no errors on this line            std::cout << "Write new master." <<std::endl;                      // error: missing ';' on return statement            return 0        } 

  2. Type errors. Each item of data in C++ has an associated type. The value 10, for example, is an integer. The word "hello" surrounded by double quotation marks is a string literal. One example of a type error is passing a string literal to a function that expects an integer argument.

  3. Declaration errors. Every name used in a C++ program must be declared before it is used. Failure to declare a name usually results in an error message. The two most common declaration errors are to forget to use std:: when accessing a name from the library or to inadvertently misspell the name of an identifier:

         #include <iostream>     int main()     {         int v1, v2;         std::cin >> v >> v2; // error: uses " v "not" v1"         // cout not defined, should be std::cout         cout << v1 + v2 << std::endl;         return 0;      } 

An error message contains a line number and a brief description of what the compiler believes we have done wrong. It is a good practice to correct errors in the sequence they are reported. Often a single error can have a cascading effect and cause a compiler to report more errors than actually are present. It is also a good idea to recompile the code after each fixor after making at most a small number of obvious fixes. This cycle is known as edit-compile-debug.


Exercises Section 1.4.2

Exercise 1.9:

What does the following for loop do? What is the final value of sum?

     int sum = 0;     for (int i = -100; i <= 100; ++i)         sum += i; 

Exercise 1.10:

Write a program that uses a for loop to sum the numbers from 50 to 100. Now rewrite the program using a while.

Exercise 1.11:

Write a program using a while loop to print the numbers from 10 down to 0. Now rewrite the program using a for.

Exercise 1.12:

Compare and contrast the loops you wrote in the previous two exercises. Are there advantages or disadvantages to using either form?

Exercise 1.13:

Compilers vary as to how easy it is to understand their diagnostics. Write programs that contain the common errors discussed in the box on 16. Study the messages the compiler generates so that these messages will be familiar when you encounter them while compiling more complex programs.


1.4.3. The if Statement

A logical extension of summing the values between 1 and 10 is to sum the values between two numbers our user supplies. We might use the numbers directly in our for loop, using the first input as the lower bound for the range and the second as the upper bound. However, if the user gives us the higher number first, that strategy would fail: Our program would exit the for loop immediately. Instead, we should adjust the range so that the larger number is the upper bound and the smaller is the lower. To do so, we need a way to see which number is larger.

Like most languages, C++ provides an if statement that supports conditional execution. We can use an if to write our revised sum program:

     #include <iostream>     int main()     {         std::cout << "Enter two numbers:" << std::endl;         int v1, v2;         std::cin >> v1 >> v2; // read input         // use smaller number as lower bound for summation         // and larger number as upper bound         int lower, upper;         if (v1 <= v2) {             lower = v1;             upper = v2;         } else {             lower = v2;             upper = v1;         }         int sum = 0;         // sum values from lower up to and including upper         for (int val = lower; val <= upper; ++val)             sum += val; // sum = sum + val         std::cout << "Sum of " << lower                   << " to " << upper                   << " inclusive is "                   << sum << std::endl;         return 0;     } 

If we compile and execute this program and give it as input the numbers 7 and 3, then the output of our program will be

   Sum of 3 to 7 inclusive is 25 

Most of the code in this program should already be familiar from our earlier examples. The program starts by writing a prompt to the user and defines four int variables. It then reads from the standard input into v1 and v2. The only new code is the if statement

     // use smaller number as lower bound for summation     // and larger number as upper bound     int lower, upper;     if (v1 <= v2) {         lower = v1;         upper = v2;     } else {         lower = v2;         upper = v1;     } 

The effect of this code is to set upper and lower appropriately. The if condition tests whether v1 is less than or equal to v2. If so, we perform the block that immediately follows the condition. This block contains two statements, each of which does an assignment. The first statement assigns v1 to lower and the second assigns v2 to upper.

If the condition is falsethat is, if v1 is larger than v2then we execute the statement following the else. Again, this statement is a block consisting of two assignments. We assign v2 to lower and v1 to upper.

1.4.4. Reading an Unknown Number of Inputs

Another change we might make to our summation program on page 12 would be to allow the user to specify a set of numbers to sum. In this case we can't know how many numbers we'll be asked to add. Instead, we want to keep reading numbers until the program reaches the end of the input. When the input is finished, the program writes the total to the standard output:

     #include <iostream>     int main()     {         int sum = 0, value;         // read till end-of-file, calculating a running total of all values read         while (std::cin >> value)             sum += value; // equivalent to sum = sum + value         std::cout << "Sum is: " << sum << std::endl;         return 0;      } 

If we give this program the input

   3 4 5 6 

then our output will be

   Sum is: 18 

Exercises Section 1.4.3

Exercise 1.14:

What happens in the program presented in this section if the input values are equal?

Exercise 1.15:

Compile and run the program from this section with two equal values as input. Compare the output to what you predicted in the previous exercise. Explain any discrepancy between what happened and what you predicted.

Exercise 1.16:

Write a program to print the larger of two inputs supplied by the user.

Exercise 1.17:

Write a program to ask the user to enter a series of numbers. Print a message saying how many of the numbers are negative numbers.


As usual, we begin by including the necessary headers. The first line inside main defines two int variables, named sum and value. We'lluse value to hold each number we read, which we do inside the condition in the while:

   while (std::cin >> value) 

What happens here is that to evaluate the condition, the input operation

   std::cin >> value 

is executed, which has the effect of reading the next number from the standard input, storing what was read in value. The input operator (Section 1.2.2, p. 8) returns its left operand. The condition tests that result, meaning it tests std::cin.

When we use an istream as a condition, the effect is to test the state of the stream. If the stream is validthat is, if it is still possible to read another input then the test succeeds. An istream becomes invalid when we hit end-of-file or encounter an invalid input, such as reading a value that is not an integer. An istream that is in an invalid state will cause the condition to fail.

Until we do encounter end-of-file (or some other input error), the test will succeed and we'll execute the body of the while. That body is a single statement that uses the compound assignment operator. This operator adds its right-hand operand into the left hand operand.

Entering an End-of-file from the Keyboard

Operating systems use different values for end-of-file. On Windows systems we enter an end-of-file by typing a control-zsimultaneously type the "ctrl" key and a "z." On UNIX systems, including Mac OS-X machines, it is usually control-d.


Once the test fails, the while terminates and we fall through and execute the statement following the while. That statement prints sum followed by endl, which prints a newline and flushes the buffer associated with cout. Finally, we execute the return, which as usual returns zero to indicate success.

Exercises Section 1.4.4

Exercise 1.18:

Write a program that prompts the user for two numbers and writes each number in the range specified by the two numbers to the standard output.

Exercise 1.19:

What happens if you give the numbers 1000 and 2000 to the program written for the previous exercise? Revise the program so that it never prints more than 10 numbers per line.

Exercise 1.20:

Write a program to sum the numbers in a user-specified range, omitting the if test that sets the upper and lower bounds. Predict what happens if the input is the numbers 7 and 3, in that order. Now run the program giving it the numbers 7 and 3, and see if the results match your expectation. If not, restudy the discussion on the for and while loop until you understand what happened.




C++ Primer
C Primer Plus (5th Edition)
ISBN: 0672326965
EAN: 2147483647
Year: 2006
Pages: 223
Authors: Stephen Prata

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net