语句和流量控制

一个简单的C ++语句是每一个程序的各个指令，象在前面的章节中看到的变量声明和表达式。他们总是用分号（结束 ;），并在它们出现在程序中相同的顺序执行。

但方案并不局限于陈述的线性序列。在其过程中，程序可能会重复的代码段，或采取决策和分叉。为了这个目的，C ++提供投放到指定哪些必须通过我们的程序，何时以及在何种情况下进行流量控制语句。

许多在本节解释了流程控制语句都需要一个通用的（子）语句作为其语法的一部分。这种说法可以是一个简单的C ++声明， -如一个单一的指令，以分号结束（ ;） -或复合语句。复合语句是一组语句（由它自己分号他们每个人的结尾），但都在一个块组合在一起，放在大括号{}：

{ statement1; statement2; statement3; } 

整个块被视为一个单独的语句（多substatements组成本身） 。每当一个通用的语句是一个流程控制语句的语法的一部分，这可以是一个简单的语句或复合语句。

选择语句：if和else

该 if关键字用于执行语句或块，当且仅当一个条件被满足。它的语法是：

if (condition) statement 

这里， condition是被评估的表达。如果这 condition是真的， statement被执行。如果是假的， statement不执行（它会被忽略），并计划在整个选择语句之后继续。
例如，下面的代码片断打印消息 (x is 100)，仅当存储在值 x变量确实100：

1 2

if (x == 100) cout << "x is 100";

如果 x是完全没有100，这一说法被忽略，并打印什么。

如果你想包括多条语句更当条件满足时要执行的，这些语句应括在大括号（ {}），形成了一个块：

1 2 3 4 5

if (x == 100) { cout << "x is "; cout << x; }

像往常一样，在代码缩进和换行没有影响，所以上面的代码就相当于：

if (x == 100) { cout << "x is "; cout << x; }

选择语句与 if也可以指定当条件不满足，使用会发生什么 else关键字来介绍一种替代说法。它的语法是： 那里的情况下，条件执行是真实的，如果不是，则执行。 例如：

if (condition) statement1 else statement2

statement1 statement2

1 2 3 4

if (x == 100) cout << "x is 100"; else cout << "x is not 100";

这版画 x is 100，如果确实x的值100，但如果没有，且仅当它不，它打印 x is not 100代替。
几个如果+ else结构可以与检查值的范围的意图并置。例如：

1 2 3 4 5 6

if (x > 0) cout << "x is positive"; else if (x < 0) cout << "x is negative"; else cout << "x is 0";

此打印x是否为正，负或零通过连接两个如果其他结构。再次，它本来也已经可以通过他们分组到花括号中的块来执行比每箱条语句的： {}。

迭代语句（循环）

循环重复语句一定的次数时，或在一个条件被满足。它们由关键字引入 while， do和 for。

while循环

最简单的循环是while循环。它的语法是： 将while循环简单地重复，同时是真实的。如果任何执行后，不再为true，循环结束，程序循环之后继续。例如，让我们来看看在使用while循环倒计时：

while (expression) statement

statement expression statement expression

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// custom countdown using while #include <iostream> using namespace std; int main () { int n = 10; while (n>0) { cout << n << ", "; --n; } cout << "liftoff!\n"; }

10，9,8，7,6，5,4，3，2，1，剥离！

编辑及运行

在第一个语句 main集合 ñ至10这个值是在倒计时的第一个数字。然后while循环开始：如果这个值满足条件 n>0（即 Ñ大于零），则下面的条件的块被执行，并重复只要条件（ n>0）保持为真。

前一方案的整个过程可以根据以下脚本（开始于被解释 main）：

1. n 被分配一个值
2. 该while条件检查（n>0）。在这一点上有两种可能性：
   
   • 条件为真：执行语句（步骤3）
     
   • 条件为假：忽略声明并继续后（步骤5）
     
3. 执行语句： （打印的价值，并减少1）
   cout << n << ", ";
--n;
nn
   
4. 块的结束。自动返回到第2步。
5. 继续运行程序块之后：
   打印liftoff!和退出程序。

考虑与while循环一件事是，环应该在某个点结束，因此，陈述须改变值在某些方面的条件检查，以迫使它成为在某些时候假的。否则，循环将继续无休止的循环下去。在这种情况下，回路包括 --n，即减小正被在条件（评价该变量的值 n）被一个-这将最终使病情（ n>0）一定数目的循环迭代后假。更具体地，经过10次迭代， n变为0，使得条件不再真实，并结束而循环。

请注意，这个循环的复杂性是微不足道的一台电脑，所以就立刻进行整体倒计时，不计数的元件之间的任何实际的延迟时间（如果有兴趣，请 sleep_for与延迟倒计时的例子）。

在do-while循环

一个非常类似的循环是do-while循环，其语法为： 它的行为就像一个while循环，除了被执行后评估，而不是之前，保证的至少一个执行，即使从未实现。例如，下面的示例程序相呼应的用户介绍，直到用户输入再见任何文本：

do statement while (condition);

condition statement statement condition

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// echo machine #include <iostream> #include <string> using namespace std; int main () { string str; do { cout << "Enter text: "; getline (cin,str); cout << "You entered: " << str << '\n'; } while (str != "goodbye"); }

输入文本：你好 您输入：你好 输入文本：谁在那里？ 您输入：谁在那里？ 输入文本：再见 您输入：再见

编辑及运行

的do-while循环是在一个while循环通常优选当 statement被至少执行一次需要，当检查结束循环的条件是在循环语句本身内确定如。在前面的例子中，块内的用户输入是将决定是否循环结束。因此，即使用户想要通过输入尽快结束循环 再见在循环块需要被至少执行一次，以提示输入，并且可以，实际上只执行它之后确定的条件。

for循环

该 for环被设计来迭代的次数。它的语法是： 像while循环，这个循环重复，同时是真实的。但是，除此之外，在for循环提供了含有特定位置和一个表达，在循环开始的第一时间之前执行，并且每次迭代之后，分别。因此，它是使用计数器变量作为特别有用。 它工作在以下方式：

for (initialization; condition; increase) statement;

statement condition initialization increase condition

1. initialization被执行。一般来说，这个声明了一个计数器变量，并将它设置一些初始值。此执行一个单一的时间，在循环的开始。
2. condition被选中。如果这是真的，则继续循环; 否则，循环结束，并且statement将被跳过，将直接到步骤5。
3. statement被执行。像往常一样，它可以是单个语句或使用大括号块{ }。
4. increase 被执行，循环回来第2步。
5. 循环结束：继续执行通过之后的下一个语句。

下面是一个使用循环倒计时例如：

1 2 3 4 5 6 7 8 9 10 11

// countdown using a for loop #include <iostream> using namespace std; int main () { for (int n=10; n>0; n--) { cout << n << ", "; } cout << "liftoff!\n"; }

10，9,8，7,6，5,4，3，2，1，剥离！

编辑及运行

在for循环的三个字段是可选的。它们可以被留为空，但是在所有情况下都需要它们之间的分号迹象。例如， for (;n<10;)是一个没有环路 初始化或 增加（相当于一while循环）; 和 for (;n<10;++n)是一个循环 的增加，但没有 初始化（也许因为变量被循环之前已经初始化）。没有一个循环 条件是等效于用循环 true作为条件（即，无限循环）。

因为每个字段中在一个循环的生命周期的特定时间被执行时，它可以比单个表达式作为任何的执行更为有用 初始化， 条件，或 语句。不幸的是，这些不是陈述，而是简单的表达式，因此，不能由一个块来代替。至于表情，他们可以，但是，请用逗号的（ ,）：这个操作符是一个表达式分离，并可以分隔多个表达式，其中普遍预计只有一个。例如，使用它，这将有可能对于一个循环处理两个计数器变量，初始化并同时增加：

1 2 3 4

for ( n=0, i=100 ; n!=i ; ++n, --i ) { // whatever here... }

此循环将执行50次，如果没有 n或 i在循环内进行修改：

 

n0的值开始，并 i用100，条件是 n!=i（即， n不等于 i）。因为 n被加一，并 i在每次迭代减少之一，在循环的情况将在50次迭代后变成假，当两个 n和 i都等于50。

基于范围循环

for循环具有另一种语法，其与范围专门用于： 这种for循环迭代中的所有元素，其中声明了一些变量能取的元素的值在该范围内。范围是元件的序列，包括阵列，容器，以及任何其他类型支承的功能

for ( declaration : range ) statement;

range declaration 开始 和  结束; 大部分这些类型的尚未被本教程中介绍的，但我们已经熟悉的至少一种的范围：字符串，这是字符的序列。

的一个例子范围为基础，使用循环字符串：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// range-based for loop #include <iostream> #include <string> using namespace std; int main () { string str {"Hello!"}; for (char c : str) { cout << "[" << c << "]"; } cout << '\n'; }

[你好][！]

编辑及运行

注意什么如何冒号（先 :在for循环是一个的声明） char变量（在字符串中的元素类型 char）。然后，我们使用这个变量， c在语句块来表示每个范围中的元素的值。

该循环是自动的，并且不需要任何计数器变量的明确声明。

基于范围的循环平时还利用类型推演用于与元素的类型 auto。典型地，基于范围的环以上，也可以写为：

1 2

for (auto c : str) cout << "[" << c << "]";

这里，类型 c被自动推导出的元素的类型 str。

跳转语句

跳转语句允许通过执行跳转到特定的位置改变一个程序的流程。

break语句

break离开一个循环，即使其端的条件不满足。它可以被用来结束无限循环，或迫使它其天然结束之前结束。例如，我们的自然结束之前停止倒计时：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// break loop example #include <iostream> using namespace std; int main () { for (int n=10; n>0; n--) { cout << n << ", "; if (n==3) { cout << "countdown aborted!"; break; } } }

10，9，8，7，6，5，4，3，倒计时中止！

编辑及运行

continue语句

该 continue语句使程序跳过循环的剩余部分在当前迭代，仿佛语句块的结尾已经达到，使其跳转至下一个迭代的开始。例如，让我们跳过在我们的倒计时数字5：

1 2 3 4 5 6 7 8 9 10 11 12

// continue loop example #include <iostream> using namespace std; int main () { for (int n=10; n>0; n--) { if (n==5) continue; cout << n << ", "; } cout << "liftoff!\n"; }

10，9,8，7，6,4，3，2，1，剥离！

编辑及运行

goto语句

goto允许使绝对跳转到程序的另一点。这种无条件跳转嵌套忽略的水平，并且不会造成任何自动栈展开。因此，它是和优选在陈述的相同的块小心使用，尤其是在局部变量的存在的特征。

目标点被识别 标签，然后将其用作一个参数 goto声明。一个 标签是由（有效标识符后跟一个冒号 :）。

goto一般认为是低级别的功能，没有特别的用例中一般用C ++采用了现代高层次的编程范式。但是，仅仅作为一个例子，这里是使用转到我们的倒计时循环的一个版本：

1 2 3 4 5 6 7 8 9 10 11 12 13

// goto loop example #include <iostream> using namespace std; int main () { int n=10; mylabel: cout << n << ", "; n--; if (n>0) goto mylabel; cout << "liftoff!\n"; }

10，9,8，7,6，5,4，3，2，1，剥离！

编辑及运行

另一种选择语句：开关。

switch语句的语法是有点奇特。其目的是要检查之间的一些可能的常量表达式的值。它类似于串联的东西 if-  else以常量表达式语句，但有限。其最典型的语法是：

switch (expression)
{
  case constant1:
     group-of-statements-1;
     break;
  case constant2:
     group-of-statements-2;
     break;
  .
  .
  .
  default:
     default-group-of-statements
}

它的工作方式如下： switch求值 expression并检查它是否相当于 constant1; 如果是，则执行 group-of-statements-1直到它找到了 break声明。当它发现这个 break声明中，程序跳转到整个的结束 switch声明（右大括号）。

如果表达不等于 constant1，则然后核对 constant2。如果它等于这一点，它执行 group-of-statements-2直到 break被发现，当它跳转到交换机的末尾。

最后，如果表达式的值没有匹配的先前指定的常量（可能有任何数量的这些），程序执行包含在后的发言 default:标签，如果它存在（因为它是可选的）。

两个以下代码片段具有相同的行为，显示了如果其他等效switch语句的：

例如切换	如果其他等效
switch (x) { case 1: cout << "x is 1"; break; case 2: cout << "x is 2"; break; default: cout << "value of x unknown"; }	if (x == 1) { cout << "x is 1"; } else if (x == 2) { cout << "x is 2"; } else { cout << "value of x unknown"; }

该 switch语句从第一个C编译器的早期继承了一个有点特殊的语法，因为它使用的标签，而不是块。在最典型的使用（如上所示），这意味着 break每个组特定标签语句之后需要语句。如果 break不包含的情况下（包括那些在任何其他标记物）以下的所有语句也执行，直到开关块的端部或一个跳转语句（如 break达到）。

如果上面的例子中缺少break语句第一组后情况时，程序不会自动跳转到开关块结束打印后 x is 1，而会继续的情况下，两（因而也打印执行的语句 x is 2）。然后，它会继续这样做，直到 break遇到声明，或年底 switch块。这使得不必要以包围了每种情况的语句在括号 {}，并且还可以是执行相同的基团为不同的可能值的语句是有用的。例如：

1 2 3 4 5 6 7 8 9

switch (x) { case 1: case 2: case 3: cout << "x is 1, 2 or 3"; break; default: cout << "x is not 1, 2 nor 3"; }

请注意， switch仅限于比较针对是常量表达式标签的计算表达式。这是不可能使用变量如标签或范围，因为它们不是有效的C ++常量表达式。

要检查的范围或不恒定的价值观，这是更好地利用串联 if 和 else if 陈述。