C++程序执行的流程结构可以有三种：顺序、分支和循环。除了最简单的顺序结构是默认的，分支和循环都需要使用专门的“流程控制语句”来定义。

1. 语句

C++中表示一步操作的一句代码，就叫做“语句”（statement），大多数语句都是以分号“;”结尾的。C++程序运行的过程，其实就是找到主函数，然后从上到下顺序执行每条语句的过程。

1.1 简单语句

使用各种运算符，作用到数据对象上，就得到了“表达式”；一个表达式末尾加上分号，就构成了“表达式语句”（expression statement）。

表达式语句表示，要执行表达式的计算过程，并且丢弃最终返回的结果。

int a = 0; // 变量定义并初始化语句

a + 1; // 算术表达式语句，无意义

++a; // 递增语句，a的值变为1

cout << " a = " << a << endl; // 输出语句

其中第二行a + 1; 是没什么意义的，因为它只是执行了加法操作，却没有把结果保存下来（赋值给别的变量），a的值也没有改变，也没有任何附带效果（比如最后一句的输出）。

最简单的语句，其实是“空语句”，就是只有一个分号的语句：

; // 空语句

这看起来好像没什么用。不过有时候，可能程序在语法上需要有一条语句，而逻辑上什么都不用做；这时就应该用一条空语句来填充。

初学C++，一定不要忘记语句末尾的分号；当然，对于不需要分号的场景，也尽量避免多写分号。

1.2 复合语句

简单语句从上到下按顺序依次执行，这非常符合我们对计算机运行的预期。但是很多场景下，简单的顺序结构远远不能满足逻辑需要：比如我们可能需要按照条件判断，做程序的分支执行；也可能需要将一段代码循环执行多次。这就需要一些“流程控制语句”（比如if、while、for等）来表达更加复杂的操作了。

而对于流程控制语句，逻辑上来说只是一条语句；事实上却可能包含了多条语句、复杂的操作。这就需要用一个花括号“{}”，把这一组语句序列包成一个整体，叫做“复合语句”（compound statement），也叫做“块”（block）。

int i = 0;

while (i < 5) {

int a = i;

++i;

}

这里的while表示一个循环，后面只能跟要循环执行的一条语句；如果我们想写两条语句，就要用花括号括起来，构成“块”。

对于复合语句（块）需要注意：

l 花括号后面不需要再加分号，块本身就是一条语句；

l 块内可以声明变量，变量的作用域仅限于块内部；

l 只有一对花括号、内部没有任何语句的块叫做“空块”，等价于空语句；

2. 条件分支

很多情况下，我们为程序的执行会提供“岔路”的选择机会。一般都是：满足某种条件就执行A操作，满足另一种条件就执行B操作……这样的程序结构叫做“条件分支”。

C++提供了两种按条件分支执行的控制语句：if和switch。

2.1 if

if语句主要就是判断一个条件是否为真（true），如果为真就执行下面的语句，如果为假则跳过。具体形式可以分为两种：一种是单独一个if，一般称为“单分支”；另一种是if … else …，称为“双分支”。

（1）单分支

单分支是最简单的if用法，判断的条件用小括号括起来跟在if后面，然后是如果条件为真要执行的语句。基本形式为：

if (条件判断)

语句

如果条件为假，那么这段代码就会被完全跳过。

我们可以举一个简单示例，判断输入的年龄数值，然后输出一句欢迎词：

#include<iostream>

using namespace std;

int main()

{

cout << "请输入您的芳龄：" << endl;

int age;

cin >> age;

if ( age >= 18 )

{

cout << "欢迎您，成年人！" << endl;

}

cin.get();

cin.get();

}

通常会用一个花括号将if后面的语句括起来，成为一个“块”。现在块里只有一条语句，所以花括号是可以省略的：

if ( age >= 18 )

cout << "欢迎您，成年人！" << endl;

如果要执行的是多条语句，花括号就不能省略；否则if后面其实就只有第一条语句。为了避免漏掉括号出现错误，一般if后面都会使用花括号。

（2）双分支

双分支就是在if分支的基础上，加了else分支；条件为真就执行if后面的语句，条件为假就执行else后面的语句。基本形势如下：

if (条件判断)

语句1

else

语句2

if分支和else分支，两者肯定会选择一个执行。

我们可以在之前程序的基础上，增加一个else分支：

if ( age >= 18 )

{

cout << "欢迎您，成年人！" << endl;

}

else

{

cout << "本程序不欢迎未成年人！" << endl;

}

我们可以回忆起来，之前介绍过的唯一一个三元运算符——条件运算符，其实就可以实现类似的功能。所以条件运算符可以认为是if … else 的一个语法糖。

以下两条语句跟上面的if…else是等价的：

// 条件运算符的等价写法

age >= 18 ? cout << "欢迎您，成年人！" << endl : cout << "本程序不欢迎未成年人！" << endl;

cout << (age >= 18 ? "欢迎您，成年人！" : "本程序不欢迎未成年人！") << endl;

（3）嵌套分支（多分支）

程序中的分支有可能不只两个，这时就需要对if分支或者else分支再做条件判断和拆分了，这就是“嵌套分支”。

简单来说，就是if或者else分支的语句块里，继续使用if或者if…else按条件进行分支。这是一种“分层”的条件判断。

if ( age >= 18 )

{

cout << "欢迎您，成年人！" << endl;

if (age < 35)

{

cout << "加油，年轻人！" << endl;

}

}

else

{

cout << "本程序不欢迎未成年人！" << endl;

if (age >= 12)

{

cout << "少年，好好学习！" << endl;

}

else

{

cout << "小朋友，别玩电脑！" << endl;

}

}

嵌套分支如果比较多，代码的可读性会大幅降低。所以还有一种更加简单的嵌套分支写法，那就是if … else if …，具体形式如下：

if (条件判断1)

语句1

else if (条件判断2)

语句2

else if (条件判断3)

语句3

…

else

语句n

这种分支的嵌套，本质上只能对else分支进行，而且只能在最底层的分支中才能执行语句。

测试代码如下：

if (age < 12) {

cout << "小朋友，别玩电脑！" << endl;

}

else if (age < 18)

{

cout << "少年，好好学习！" << endl;

}

else if (age < 35)

{

cout << "加油，年轻人！" << endl;

}

else if (age < 60)

{

cout << "加油，中年人！" << endl;

}

else

{

cout << "好好休息，老年人！" << endl;

}

2.2 switch

在一些应用场景中，要判断的条件可能不是范围，而是固定的几个值。比如考试成绩只分“A”“B”“C”“D”四个档位，分别代表“优秀”“良好”“及格”“不及格”。

这个时候如果用if … else会显得非常繁琐，而swith语句就是专门为了这种分支场景设计的。

switch语法基本形式如下：

swith (表达式){

case 值1:

语句1

break;

case 值2:

语句2

break;

…

default:

语句n

break;

}

这里switch后面的括号里是一个表达式，对它求值，然后转换成整数类型跟下面每个case后面的值做比较；如果相等，就进入这个case指定的分支，执行后面的语句，直到swith语句结束或者遇到break退出。需要注意的是：

case关键字和后面对应的值，合起来叫做一个“case标签”；case标签必须是一个整型的常量表达式；任何两个case标签不能相同；break语句的作用是“中断”，会直接跳转到switch语句结构的外面；如果没有break语句，那么匹配某个case标签之后，程序会从上到下一直执行下去；这会执行多个标签下面的语句，可能发生错误；如果没有匹配上任何case标签的值，程序会执行default标签后面的语句；default是可选的，表示“默认要执行的操作”。

我们可以利用swith写一个判断考试成绩档位，输入一句相应的话：

#include<iostream>

using namespace std;

int main()

{

cout << "请输入您的成绩：" << endl;

char score;

cin >> score;

switch (score)

{

case 'A':

cout << "成绩优秀！" << endl;

break;

case 'B':

cout << "成绩良好！" << endl;

break;

case 'C':

cout << "恭喜！及格了！" << endl;

break;

case 'D':

cout << "欢迎下次再来！" << endl;

break;

default:

cout << "错误的成绩输入！" << endl;

break;

}

cin.get();

cin.get();

}

3 循环

可以重复执行一组操作的语句叫做“循环”，有时也叫作“迭代”。循环一般不能无限进行下去，所以会设置一个终止的判断条件。

C++中的循环语句，有while、do while和for三种。

3.1 while

while只需要给定一个判断条件，只要条件为真，就重复地执行语句。形式如下：

while (条件)

语句

要执行的语句往往会有多条，这就需要用花括号将它们括起来。这个块一般被称为“循环体”。

一般来说，用来控制while循环的条件中一定会包含变量，通常叫做“循环变量”；而它或者在条件中变化，或者在循环体中变化，这样才能保证循环能够终止退出。

比如我们可以用一个循环输出10次“Hello World”，并且打印出当前循环次数：

#include<iostream>

using namespace std;

int main()

{

cout << "循环开始...\n" << endl;

int i = 1;

while (i <= 10)

{

cout << "Hello World!" << endl;

cout << "现在是第" << i << "次循环\n" << endl;

++i;

}

cout << "循环结束!" << endl;

cin.get();

}

这里需要注意，循环体最后的 ++i一定不能漏掉。如果没有这条语句，i的值就不会更改，循环就永远不会退出。

3.2 do while

do while和while非常类似，区别在于do while是先执行循环体中的语句，然后再检查条件是否满足。所以do while至少会执行一次循环体。

do while语法形式如下：

do

语句

while (条件)

我们可以接着之前while循环的代码继续测试：

do

{

cout << "现在是倒数第" << --i << "次循环" << endl;

cout << "GoodBye World!\n" << endl;

} while (i > 1);

由于之前的变量i已经做了10次递增，因此do wihle开始时i的值为11。进入循环体直接输出内容，每次i递减1，直到i = 1时退出循环。

3.3 for

通过while和do while可以总结出来，一个循环主要有这样几个要素：

l 一个条件，用来控制循环退出；

l 一个循环体，用来定义循环要执行的操作；

而一般情况下，我们都是通过一个循环变量来控制条件的，这个变量需要随着循环迭代次数的增加而变化。while和do while的循环变量，都是在循环体外单独定义的。

for是用法更加明确的循环语句。它可以把循环变量的定义、循环条件以及循环变量的改变都放在一起，统一声明出来。

（1）经典for循环

for循环的经典语法形式是：

for (初始化语句; 条件; 表达式)

语句

关键字for和它后面括号里的部分，叫做“for语句头”。

for语句头中有三部分，用分号分隔，主要作用是：

初始化语句负责初始化一个变量，这个变量值会随着循环迭代而改变，一般就是“循环变量”；中间的条件是控制循环执行的关键，为真则执行下面的循环体语句，为假则退出。条件一般会以循环变量作为判断标准；最后的表达式会在本次循环完成之后再执行，一般会对循环变量进行更改；

这三个部分并不是必要的，根据需要都可以进行省略。如果省略某个部分，需要保留分号表示这是一个空语句。

我们可以用for循环语句，实现之前输出10次“Hello World”的需求：

#include<iostream>

using namespace std;

int main()

{

for (int i = 1; i <= 10; i++)

{

cout << "Hello World!" << endl;

cout << "现在是第" << i << "次循环！\n" << endl;

}

cin.get();

}

（2）范围for循环

C++ 11新标准引入了一种更加简单的for循环，这种语句可以直接遍历一个序列的所有元素。这种for循环叫做“范围for循环”。语法形式如下：

for (声明: 序列表达式)

语句

这里for语句头中的内容就很简单了，只需要声明一个变量，后面跟上一个冒号（注意不是分号），再跟上一个序列的表达式就可以了。所谓“序列”，其实就是一组相同类型的数据对象排成了一列来统一处理；所以这个声明的意思，其实就是从序列中依次取出所有元素，每次都赋值给这个变量。

所以范围for循环的特点就是，不需要循环变量，直接就可以访问序列中的所有元素。

// 范围for循环

for (int num : {3, 6, 8, 10})

{

cout << "序列中现在的数据是：" << num << endl;

}

这里用花括号把一组数括起来，就构成了最简单的序列：{3, 6, 8, 10}。后面将要介绍的数组，以及vector、string等类型的对象，也都是序列。

3.4 循环嵌套

循环语句和分支语句一样，也是可以进行嵌套的。具体可以while循环中嵌套while，可以for循环中嵌套for，也可以while、do while和for混合嵌套。因为for的循环变量定义更明确，所以一般用for的循环嵌套会多一些。

for (int i = 0; i < 3; i++)

{

for (int j = 0; j < 5; j++)

{

cout << "Hello World! i = " << i << ", j = " << j << endl;

}

}

循环嵌套之后，内层语句执行的次数，将是外层循环次数和内层循环次数的乘积。这会带来大量的时间消耗，使程序运行变慢，所以使用嵌套循环要非常谨慎。

下面是一个使用双重for循环，打印输出“九九乘法表”的例子。

#include<iostream>

using namespace std;

int main()

{

// i表示行数，j表示列数

for (int i = 1; i < 10; i++)

{

for (int j = 1; j <= i; j++) {

cout << j << " × " << i << " = " << i * j << "\t";

}

cout << endl;

}

cin.get();

}

这里使用内外两层for循环，实现了一个二维“表”的输出。后面我们会看到，循环嵌套对于处理多维数据非常有用。

4 跳转

在流程控制语句中还有一类“跳转语句”，主要用来中断当前的执行过程。C++中有四种跳转语句：break，continue，goto以及return。

4.1 break

break语句表示要“跳出”当前的流程控制语句，它只能出现在switch或者循环语句（while、do while、for）中。当代码中遇到break时，会直接中断距离最近的switch或者循环，跳转到外部继续执行。

int i = 0;

while (true)

{

cout << " Hello World! " << endl;

cout << " 这是第" << ++i << "次输出\n" << endl;

if (i >= 5)

{

break;

}

}

如果循环条件永远为真，那么循环体中一定要有break，保证在某种情况下程序可以退出循环。

4.2 continue

continue语句表示“继续”执行循环，也就是中断循环中的本次迭代、并开始执行下一次迭代。很明显，continue只能用在循环语句中，同样针对最近的一层循环有效。

continue非常适合处理需要“跳过”某些情况的场合。

// 逢7过

for (int num = 1; num < 100; num++)

{

cout << "\t";

// 如果是7的倍数，或者数字中有7，则跳过

if (num % 7 == 0 || num % 10 == 7 || num / 10 == 7)

continue;

cout << num;

// 如果是10的倍数，则换行

if (num % 10 == 0)

cout << endl << endl;

}

上面模拟了一个经典的小游戏“逢7过”，如果遇到7的倍数比如7、14、21，或者数字中有7比如17、27、71，都要跳过。

4.3 goto

goto语句表示无条件地跳转到程序中的另一条语句。goto的语法形式为：

goto 标签;

这里的“标签”可以认为是一条语句的“名字”，跟变量类似，只不过它是指代一条语句的标识符。定义标签也非常简单，只要在一条语句前写出标识符，然后跟上冒号就可以了，比如：

begin: int a = 0;

下面是一个具体的例子：

int x = 0;

cout << "程序开始..." << endl;

begin:

do

{

cout << " x = " << ++x << endl;

} while (x < 10);

if (x < 15) {

cout << "回到原点！" << endl;

goto begin;

}

cout << "程序结束！" << endl;

由于goto可以任意跳转，所以它非常灵活，也非常危险。一般在代码中不要使用goto。

4.4 return

return是用来终止函数运行并返回结果的。之前的Hello World程序中就曾经介绍，主函数最后的那句 return 0; 就是结束主函数并返回结果，一般这句可以省略。

而在自定义的函数中，同样可以用return来返回。

5. 应用案例

综合利用分支和循环语句，就可以实现很多有趣的功能。

5.1 判断质数

质数也叫素数，是指一个大于1的自然数，因数只有1和它自身。质数是数论中一个经典的概念，很多著名定理和猜想都跟它有关；质数也是现代密码学的基础。

判断一个数是否为质数没有什么规律可言，我们可以通过验证小于它的每个数能否整除，来做暴力求解。下面是一段判断质数、并输出0~100内所有质数的程序：

#include<iostream>

using namespace std;

// 定义一个判断质数的函数，用return返回判断结果

bool isPrime(int num)

{

int i = 2;

while (i < num)

{

if (num % i == 0) return false;

++i;

}

return true;

}

int main()

{

cout << "请输入一个自然数（不超过20亿）：" << endl;

int num;

cin >> num;

if (isPrime(num))

{

cout << num << "是质数！" << endl;

}

else

{

cout << num << "不是质数！" << endl;

}

cout << "\n=========================\n" << endl;

cout << "0 ~ 100 内的质数有：" << endl;

for (int i = 2; i <= 100; i++)

{

if (isPrime(i))

cout << i << "\t";

}

cout << endl;

cin.get();

cin.get();

}

5.2 猜数字

猜数字是一个经典的小游戏，程序随机生成一个0~100的数字，然后由用户输入来猜测。如果猜对，输出结果并退出；如果不对，则提示偏大还是偏小。我们可以对猜的次数做限制，比如一共5次机会。

#include<iostream>

using namespace std;

int main()

{

cout << "=========猜数字========" << endl;

cout << "规则：输入0~100的整数，有5次机会\n" << endl;

// 以当前时间为随机数种子，生成一个0~100的伪随机数

srand(time(0));

int target = rand() % 100;

int n = 0; // 猜的次数

while (n < 5)

{

cout << "请输入0~100的整数：" << endl;

int num;

cin >> num;

if (num == target)

{

cout << "恭喜你，猜对了！ 幸运数字是：" << target << endl;

break;

}

else if (num > target)

cout << "数字太大了！再猜一遍！" << endl;

else

cout << "数字太小了！再猜一遍！" << endl;

++n;

}

if (n == 5)

cout << "已经猜过5遍，没有猜中！欢迎下次再来！" << endl;

cin.get();

cin.get();

}