代写C代码 代做C程序 C辅导 C家教

1.4. Control Structures

1.4. 控制结构

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.

语句总是顺序执行的：函数的第一条语句首先执行，接着是第二条，依次类推。当然，少数程序——包括我们将要编写的解决书店问题的程序——可以仅用顺序执行语句编写。事实上，程序设计语言提供了多种控制结构支持更为复杂的执行路径。本节将简要地介绍 C++ 提供的控制结构，第六章再详细介绍各种语句。

1.4.1. The while Statement

1.4.1. while 语句

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:

while 语句提供了迭代执行功能。可以用 while 语句编写一个如下所示的从 1 到 10（包括 10）的求和程序：

    #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.

与前面一样，程序首先包含 iostream 头文件并定义 main 函数。在 main 函数中定义两个 int 型变量：sum 保存总和，val 表示从 1 到 10 之间的每一个值。我们给 sum 赋初值 0，而 val 则从 1 开始。

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

重要的部分是 while 语句。while 结构有这样的形式：

   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.

while 通过测试 condition （条件）和执行相关 while_body_statement 来重复执行，直到 condition 为假。

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.

如果 condition 为真（表达式求值不为零），则执行 while_body_statement。执行完后，再次测试 condition 。如果 condition 仍为真，则再次执行 while_body_statement。while 语句一直交替测试 condition 和执行 while_body_statement，直到 condition 为假为止。

In this program, the while statement is:

在这个程序中，while 语句是

    // 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:

while 语句的条件用了小于或等于操作符（<= 操作符），将 val 的当前值和 10 比较，只要 val 小于或等于 10，就执行 while 循环体。这种情况下，while 循环体是一个包含两个语句的块：

    {        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:

块是被花括号括起来的语句序列。C++ 中，块可用于任何可以用一条语句的地方。块中第一条语句使用了复合赋值操作符（+= 操作符），这个操作符把它的右操作数加至左操作数，这等效于编写含一个加法和一个赋值的语句：

    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.

因此第一条语句是把 val 的值加到 sum 的当前值，并把结果存入 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.

使用了前自增操作符（++ 操作符），自增操作符就是在它的操作数上加 1，++val 和 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.

执行 while 的循环体后，再次执行 while 的条件。如果 val 的值（自增后）仍小于或等于 10，那么再次执行 while 的循环体。循环继续，测试条件并执行循环体，直到 val 的值不再小于或等于 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.

一旦 val 的值大于 10，程序就跳出 while 循环并执行 while 后面的语句，此例中该语句打印输出，其后的 return 语句结束 main 程序。

1.4.2. The for Statement

1.4.2. for 语句

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.

在 while 循环中，我们使用变量 val 来控制循环执行次数。每次执行 while 语句，都要测试 val 的值，然后在循环体中增加 val 的值。

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:

由于需要频频使用像 val 这样的变量控制循环，因而 C++ 语言定义了第二种控制结构，称为 for 语句，简化管理循环变量的代码。使用 for 循环重新编写求 1 到 10 的和的程序，如下：

    #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 循环之前，我们定义 sum 并赋 0 值。用于迭代的变量 val 被定义为 for 语句自身的一部分。for 语句

    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

包含 for 语句头和 for 语句体两部分。for 语句头控制 for 语句体的执行次数。for 语句头由三部分组成：一个初始化语句，一个条件，一个表达式。在这个例子中，初始化语句

    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 的 int 对象并给定初始值 1。初始化语句仅在进入 for 语句时执行一次。条件

    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.

将 val 的当前值和 10 比较，每次经过循环都要测试。只要 val 小于或等于 10，就执行 for 语句体。仅当 for 语句体执行后才执行表达式。在这个 for 循环中，表达式使用前自增操作符，val 的值加 1，执行完表达式后，for 语句重新测试条件，如果 val 的新值仍小于或等于 10，则执行 for 语句体，val 再次自增，继续执行直到条件不成立。

In this loop, the for body performs the summation

在这个循环中，for 语句体执行求和

  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.

for 语句体使用复合赋值操作符，把 val 的当前值加到 sum，并将结果保存到 sum 中。

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

扼要重述一下，for 循环总的执行流程为：

 

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. 退出 for 循环后，变量 val 不再可访问，循环终止后使用 val 是不可能的。然而，不是所有的编译器都有这一要求。

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.

在标准化之前的 C++ 中，定义在 for 语句头的名字在 for 循环外是可访问的。语言定义中的这一改变，可能会使习惯于使用老式编译器的人，在使用遵循标准的新编译器时感到惊讶。

 

1.4.3. The if Statement

1.4.3. if 语句

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.

求 1 到 10 之间数的和，其逻辑延伸是求用户提供的两个数之间的数的和。可以直接在 for 循环中使用这两个数,使用第一个输入值作为下界而第二个输入值作为上界。然而, 如果用户首先给定的数较大，这种策略将会失败：程序会立即退出 for 循环。因此，我们应该调整范围以便较大的数作上界而较小的数作下界。这样做，我们需要一种方式来判定哪个数更大一些。

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

像大多数语言一样，C++ 提供支持条件执行的 if 语句。使用 if 语句来编写修订的求和程序如下：

    #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

如果我们编译并执行这个程序给定输入数为 7 和 3，程序的输出结果将为：

  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

这个程序中大部分代码我们在之前的举例中已经熟知了。程序首先向用户输出提示并定义 4 个 int 变量，然后从标准输入读入值到 v1 和 v2 中。仅有 if 条件语句是新增加的代码：

    // 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.

这段代码的效果是恰当地设置 upper 和 lower 。if 的条件测试 v1 是否小于或等于 v2。如果是，则执行条件后面紧接着的语句块。这个语句块包含两条语句，每条语句都完成一次赋值，第一条语句将 v1 赋值给 lower ，而第二条语句将 v2 赋值给 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.

如果这个条件为假（也就是说，如果 v1 大于 v2）那么执行 else 后面的语句。这个语句同样是一个由两个赋值语句组成的块，把 v2 赋值给 lower 而把 v1 赋值给 upper 。

1.4.4. Reading an Unknown Number of Inputs

1.4.4. 读入未知数目的输入

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:

对第 1.4.1 节的求和程序稍作改变，还可以允许用户指定一组数求和。这种情况下，我们不知道要对多少个数求和，而是要一直读数直到程序输入结束。输入结束时，程序将总和写到标准输出：

    #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

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:

与平常一样，程序首先包含必要的头文件。main 中第一行定义了两个 int 变量，命名为 sum 和 value。在 while 条件中，用 value 保存读入的每一个数：

  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.

它具有从标准输入读取下一个数并且将读入的值保存在 value 中的效果。输入操作符（第 1.2.2 节）返回其左操作数。while 条件测试输入操作符的返回结果，意味着测试 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.

当我们使用 istream 对象作为条件，结果是测试流的状态。如果流是有效的（也就是说，如果读入下一个输入是可能的）那么测试成功。遇到文件结束符或遇到无效输入时，如读取了一个不是整数的值，则 istream 对象是无效的。处于无效状态的 istream 对象将导致条件失败。

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.

在遇到文件结束符（或一些其他输入错误）之前，测试会成功并且执行 while 循环体。循环体是一条使用复合赋值操作符的语句，这个操作符将它的右操作数加到左操作数上。

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.

一旦测试失败，while 终止并退出循环体，执行 while 之后的语句。该语句在输出 sum 后输出 endl，endl 输出换行并刷新与 cout 相关联的缓冲区。最后，执行 return，通常返回零表示程序成功运行完毕。