【C++探索之旅】第一部分第六课：控制流程，随心所至

标签：条件表达式   循环   c++   程序员联盟   coderunity   

内容简介

1、第一部分第六课：控制流程，随心所至

2、第一部分第七课预告：函数效应，分而治之

控制流程，随心所至

上一课《【C++探索之旅】第一部分第五课：简易计算器》比较简单，这一课也不难，却很重要。

其实目前来说，基础部分和《C语言探索之旅》有些类似。难免有些重复，毕竟C++从C语言借鉴了不少。不过小编保证之后进入C++的面向对象编程部分，才是精彩中的精彩。敬请期待~

好了，扯回正题。

大家应该看过不少科幻片吧，其中很大一部分是说电脑发展起来成为人工智能和人类打架的（反正最终都是呆萌的人类如小强般获胜。唉，拍来拍去就是那么些剧情，世间导演的想象力也真不过尔尔）。

但是小编认为电脑再厉害也绝不可能有自我意识，毕竟人是独一无二的创造。

电脑既然没有自我意识，那么它就是按照我们给其编写好的程序去做各种事情的。而其中最关键的就是：程序需要能作各样决定。

为了达成这个目的，计算机科学家们设计了"控制结构"（Control Structure）。这个词听上去还真有点抽象，不过不要担心，学完这一课就很清楚了。

控制结构主要包含两种元素：

1. 条件：使我们可以在程序中写一些规则，例如：如果满足这个条件，就做相应的事。

2. 循环：使我们可以重复执行一系列的指令。

可以说，控制结构是每种编程语言的根本。没有控制结构，你的程序就没什么复杂逻辑可言。当然，假如你的程序只是简单地输出一些数据，那么也可以不用控制结构。但是，你的程序肯定不能做更厉害的事。

虽然这一课不太难，但是基本概念还是要掌握好，这样之后的课程才能有基（基础）可趁。

条件

为了使我们的程序可以做决定，我们需要用到条件语句（有时也称为条件结构）。原理很简单：你希望你的程序能依据不同的情况作出相应的表现。

首先，我们需要知道：我们可以用条件语句测试变量。什么意思呢？还记得我们前两课里学习过的变量吗？这些存储在内存中的值，我们现在要学着分析它们。例如：

这个整型变量大于10吗？

这个字符串变量里包含密码吗？

等等。

为了做测试判断，我们需要用到条件判断符号。如下表所示：

不难吧，小学数学老师都教过。

注意：在C++中，测试是否相等用两个等号相连（==）。即使是编程老手也会经常漏写成一个等号（=），以致于变成赋值而不是判断相等了。

在条件语句中，我们将用这些符号来做一些比较。

在C++中，我们可以用几种不同形式的条件语句来做测试。其中最重要的，也是最常用，不可避免要了解的，就是if条件语句。

if条件语句

if是英语"假如，如果"的意思。

在开始使用if条件语句之前，我们先自己写一个基础程序。

今天正好我们其中一个同事买了一些croissant（法国的羊角面包）之类的来庆祝，他6个月后将有第一个孩子了。就写一个关于孩子数目的程序吧。

#include <iostream>
using namespace std;

int main()
{    
    int childrenNb(2);  // 孩子数目    
    return 0;
}

上面的代码目前几乎没做什么，只是声明了一个int型变量，名叫childrenNb（表示"孩子数目"，children是英语"孩子"的意思。Nb是number的缩写，表示"数目"），初始值为2。

在扩充此程序之前，我们先来了解一下if语句的逻辑：

如果 满足一定条件

则 执行指定操作

所以单一的if语句是这样写的：

1. 先写一个if

2. 接着写一个括号()，在这个括号中写条件

3. 接着写一个大括号{}，在大括号中写()中条件为真时所要执行的操作

格式如下：

if (/* 条件 */)
{
  // 如果条件为真，所要执行的操作
}

假设我们的程序在孩子数大于0时会显示一句祝贺的话。我们需要加一个条件，此条件是用来判断孩子数是否大于0。假如大于0，则打印信息。程序扩充如下：

#include <iostream>
using namespace std;

int main()
{    
    int childrenNb(2);  // 孩子数目
    
    if (childrenNb > 0)  // 如果孩子数大于0    
    {        
        cout << "你有孩子，真棒!" << endl;    
    }
    
    return 0;
}

我们仔细看关键的那句话：

if (childrenNb > 0)

就是这句话，做了条件表达式的判断。

它所做的测试是这样：

假如孩子数大于0。

如果这句条件表达式是真的（我们的孩子数目childrenNb是2，确实大于0），那么程序就会执行大括号里面的语句，也就是:

cout << "你有孩子，真棒!" << endl;

在控制台打印出 "你有孩子，真棒!"。

============

闲话一下代码的格式

假如上面的代码我们写成:

if (childrenNb>0) {cout<< "你有孩子，真棒!" <<endl;}

程序也是可以正确运行的，但是非常不推荐这样的代码格式！

如果我们的程序没有空行，没有空格，不缩进，都写在一行里，那将会使代码非常难以阅读。而且不美观，这年头颜值是很重要的。

所以从一开始学习编程就请养成良好的编码习惯，不然以后写一些大型程序，别人根本不知道怎么阅读你的代码，你也会迷失在自己的代码里。

推荐看林锐老师的《高质量C++/C 编程指南》一书，里面有提到编码规范，可以去网上下载PDF。

当然每个程序员的代码风格都不一样，但是我们推荐大家遵从本系列课程中的代码格式，因为是比较通用的编码格式。

============

假如if后面的括号里的条件表达式为假又如何呢？也就是说childrenNb不大于0。

那么，程序就不会执行大括号中的语句，而是直接转到 return 0; 然后就结束程序了。程序就不会打印任何信息。

测试一下上面的程序，修改childrenNb的值，看看结果如何。

else语句：假如条件不成立

现在你知道怎么写单一的if语句了，那当条件为假时，我们要电脑也执行对应的操作怎么办呢？对了，就轮到else关键字出场了。

else是英语"否则，要不然"的意思。

注意：else语句一定要跟if语句配合才能使用，独立的else语句是不可用的！

【至于什么是关键字：关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，是有特别意义的变量。

C++有不少，比如int，float，char，double，if，else，等，暂时我们不多涉及，可以去了解一下。】

我们扩充以上程序：

#include <iostream>
using namespace std;

int main()
{
    int childrenNb(0);
    
    if (childrenNb > 0)
    {
        cout << "你有孩子，真棒!" << endl;
    }
    else
    {
        cout << "你没孩子，加油." << endl;
    }
    
    return 0;
}

运行以上程序，显示：

你没孩子，加油.

因为我们的childrenNb变量的值为0，因此childrenNb > 0这个条件表达式不为真，执行else后面的大括号里的语句：

cout << "你没孩子，加油." << endl;

以上程序的逻辑如下图所示：

else...if语句：做另一个测试

上面我们学习了如何用单一的if语句，以及if...else语句。

其实除了“假如...”（if语句）和“否则...”（else语句），还有else...if（“又假如”）语句，用于在if语句的条件不为真时对其他的情况的判断，else…if语句放在if语句和else语句之间

总的逻辑是这样的：

如果 变量值为A，则执行if对应操作

如果 变量值不为A，而为B，则执行else...if对应操作

如果 变量值既不为A也不为B，则执行else对应操作

总的流程是这样的：

1. 首先判断if语句中的括号里的表达式，如果为真，则执行第一个大括号里的语句。

2. 如果if的条件不为真，则接着判断else…if语句的括号里的表达式，如果为真，则执行对应的大括号里面的语句。

3. 如果if和else…if里的表达式都为假，则无需再判断，直接执行else语句的大括号里的命令。

我们再修改扩充以上程序，将其逻辑改为：

如果 孩子数为0，则打印：你没有孩子

如果 孩子数不为0，而为1，则打印：啥时生第二个？

如果 孩子数既不为0也不为1，而为2，则打印：多好的孩子

如果 孩子数既不为0也不为1也不为2，而是比2更多，则打印：差不多了吧

程序如下：

#include <iostream>
using namespace std;

int main()
{
    int childrenNb(2);
    
    if (childrenNb == 0)
    {
        cout << "你没有孩子" << endl;
    }
    else if (childrenNb == 1)
    {
        cout << "啥时生第二个?" << endl;
    }
    else if (childrenNb == 2)
    {
        cout << "多好的孩子" << endl;
    }
    else
    {
        cout << "差不多了吧" << endl;
    }
    
    return 0;
}

逻辑如下图所示：

而上面的程序，聪明如你应该知道会打印：

多好的孩子

switch条件语句

我们刚学的if...else类型的条件语句是最常用的。理论山，if...else语句可以满足所有的条件判断需求了。

不过C++还提供了一个不是那么全面的替代品：switch语句。

因为有时候，当我们的条件判断很多时，就会感觉冗余。switch可用于测试同一个变量的多个可能的值。

switch是英语"开关，转换"的意思。

我们先来看看用switch语句如何实现上面的同样逻辑：

#include <iostream>
using namespace std;

int main()
{
    int childrenNb(3);
    
    switch (childrenNb)
    {
        case 0:
            cout << "你没有孩子" << endl;
            break;
        case 1:
            cout << "啥时生第二个?" << endl;
            break;
        case 2:
            cout << "多好的孩子" << endl;
            break;
        default:
            cout << "差不多了吧" << endl;
            break;
    }
    
    return 0;
}

相比if...else，switch语句虽然用得较少，但是对于判断情况很多的条件语句，用switch是不是可以少写不少代码呢，而且程序也一目了然，比较清晰。

switch语句的格式：

1. 首先，写switch这个关键字，接着写一个括号，括号里面是要判断的变量

2. case加上变量可能的取值，再加一个冒号，再加上对应取值时的操作，再加上一个break;

3. 要注意：case后面的值只能是整型或字符型的常量或常量表达式

4. default负责处理除了各个case以外的情况
   

5. 多个case就相当于if...else语句里的if和else...if

6. default相当于if...else语句里的else

想 想看，switch语句是不是很像我们去饭店用餐，服务员拿了一个酒水单给你，上面有好多饮料，就像好多个case后面的取值。你点一种饮料，服务生就去 给你拿对应的饮料，这个操作就像case的冒号后面的语句。假如你什么都不要，说：还是给我来杯水吧。那服务生就只能给你拿一杯水了，就相当于 default。

每个 case 语句的结尾不要忘了加 break，否则将导致多个分支重叠(除非有意使多个分支重叠)。

例如：

#include <iostream>
using namespace std;

int main()
{    
    int childrenNb(0);
    
    switch (childrenNb)    
    {        
        case 0:            
            cout << "你没有孩子" << endl;            
            // 这里我们没有写 break;
        case 1:            
            cout << "啥时生第二个?" << endl;            
            break;        
        case 2:            
            cout << "多好的孩子" << endl;            
            break;        
        default:            
            cout << "差不多了吧" << endl;            
            break;    
    }    
    
    return 0;
}

运行以上程序，你会发现输出是：

你没有孩子

啥时生第二个?

很奇怪吧。

这是因为没有break，程序就不跳出switch的大括号，而继续执行，“穿透”了case 1，虽然childrenNb的值是0，不等于1，但是也执行了case 1对应的语句 cout << "啥时生第二个?" << endl;

又因为case 1的执行语句后面加了break，所以程序执行完 cout << "啥时生第二个?" << endl; 就跳出了switch语句。

当然有时候也有故意不加break，使得多个情况做同一个操作的，例如：

#include <iostream>

using namespace std;

int main()
{
    int childrenNb(1);
    
    switch (childrenNb)
    {
        case 0:
            cout << "你没有孩子" << endl;
            break;
        case 1:
        case 2:
            cout << "你有孩子" << endl;
            break;
        default:
            cout << "差不多了吧" << endl;
            break;
    }
    
    return 0;
}

上面的代码，当childrenNb的值为1或2时，都会执行 cout << "你有孩子" << endl;

是不是很妙呢？

还有要注意的是：

最后记得使用 default 分支。虽然default不加其实也不会报错，但即使程序真的不需要 default 处理,也应该保留语句，这样做并非画蛇添足，可以避免让人误以为你忘了 default 处理。要把 default 子句只用于检查真正的默认情况。

三元表达式：精简的条件语句

除了if...else语句和switch语句，还有第三种条件语句，比switch更少用。

我们将其称为 三元表达式。

更确切地说，其实它就是一个if...else的变体，只不过我们把它写在一行里了。

因为实例总比长篇的解释来得更清晰易懂，所以我们用两个例子来说明。

这两个例子的功能相同，只不过第一个使用if...else语句，第二个使用三元表达式。

我们还是用childrenNb这个整型变量来举例子。此时再加一个string变量message，表示打印的信息（message是英语"消息，信息"的意思）。

逻辑很简单，当childrenNb大于0时，message变成"你有孩子"；如果childrenNb不大于0，message变成"你没有孩子"。

下面先给出if...else的实现：

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int childrenNb(2);
    string message("");
    
    if (childrenNb > 0)
        message = "你有孩子";
    else
        message =  "你没有孩子";
        
    cout << message << endl;
    
    return 0;
}

注意：

上例中我把if和else对应的大括号给去掉了。在只有一句执行语句的时候，去掉大括号是可以的，两句或以上就须要加上大括号了。不过一般不推荐不加大括号，即使只有一句指令也应该加上大括号，以防以后出现问题。

上面的程序用三元表达式实现则是这样：

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int childrenNb(2);
    string message("");
    
    message = childrenNb > 0 ? "你有孩子" : "你没有孩子";
    
    cout << message << endl;
    
    return 0;
}

三元表达式使我们可以只用一行代码来根据条件改变变量的值。

问号表示首先判断childrenNb > 0是不是真。如果是真，则取问号后面的"你有孩子"，将"你有孩子"赋给message；如果为假，取冒号后面的"你没有孩子"，将"你没有孩子"赋给message。

这里的问号就有点像if的条件判断，冒号就像else。

事实上，三元表达式并不是那么常用，因为它会使代码变得难读，特别是当判断条件多且复杂的时候。

布尔变量和条件组合

我们再继续深入学习条件语句，来看看两个概念：布尔变量和条件组合。

布尔变量

你还记得之前变量那一课我们在列表中见到的bool吗？这种类型的变量只能储存以下两个值中的一个：

1. true (真) ;

2. false (假).

因此bool变量的值，不是true，就是false。true是英语"真"的意思，而false是"假"的意思。

其实，布尔变量就是条件表达式的核心。因为我们之前说的类似 childrenNb > 0 是否为真，就是指整个表达式（childrenNb > 0）是否等于true。如果为真，则是true；如果为假，则是false。

例如：

bool hasChildren(true);

if (hasChildren == true)
{
    cout << "你有孩子" << endl;
}

我们也可以精简一些：

bool hasChildren(true);

if (hasChildren)
{
    cout << "你有孩子" << endl;
}

我们也可以这样写：

bool hasChildren(false);
int childrenNb(2);

hasChildren = childrenNb > 0;

if (hasChildren)
{
    cout << "你有孩子" << endl;
}
else
{
    cout << "你没有孩子" << endl;
}

条件组合

我们也可以在条件语句的括号()中测试多个条件表达式。例如，你想要测试一个人的年龄是不是介于18岁和25岁之间，就需要两个条件表达式来判断了。

为了达成我们的目的，我们需要用到新的符号：

本来其实上表中的几个应该叫做：与，或，非，但为什么叫“逻辑与”，“逻辑或”和“逻辑非”呢？

那是因为之后我们还会学到 &，| 等符号，称为“按位或”和“按位与”。暂时不用知道什么意思。

逻辑与

如果我们要做上面提到过的年龄的判断，则需要用逻辑与：

if (age > 18 && age < 25)

两个 & 号连在一起表示逻辑与，就是说当两边的表达式都为真时，括号中的整个表达式才为真，所以这里只有当age大于18并且小于25的情况下，括号里的表达式才为真。

逻辑或

为了做逻辑或判断，我们则要用到两个 | 符号。逻辑或只要其两边的两个表达式有一个为真，整个表达式就为真。我承认这个符号在键盘上不容易输入。

假设我们现在要写一个程序，目的是判断一个人是不是够资格开设银行账户。众所周知，要开一个银行账户，申请人不能太年幼（我们假定需要大于20岁）或者有很多钱（有钱任性嘛，即使是10岁小孩，也得让他开户）。所以我们的程序是像以下这样：

if (age > 20 || money > 150000)
{
    cout << "欢迎来到**银行 !" << endl;
}
else
{
    cout << "我还不够资格，悲催啊 !" << endl;
}

所以这个测试只有当申请人年龄大于20岁或者拥有超过15万现金时，才让其开户。

逻辑非

我们最后要看的符号是感叹号，表示“取反”，加在表达式之前。如果表达式为真，那么加上感叹号则为假；如果表达式为假，那么加上感叹号则为真。例如：

if (!(age < 18))

上面的表达式表示“假如已经成年”。

当然，逻辑与和逻辑或可以连用，甚至多个一起用，例如：

if ((age > 18 && age < 25) || age < 4)

一些容易犯的错误

== 号

不要忘了之前讲过的 == （两个等号）是用于判断是否相等。例如：

if (age == 18)
{
    cout << "你刚成年 !" << endl;
}

上例中如果错把 == （两个等号）写成了 = （单个等号），那后果很严重，表达式就变成 age = 18了。单个等号是赋值，所以age变为18，整个表达式的值变为18，就起不到判断的作用了。

一种避免这样错误的写法是“18 == age”，这样如果我们漏写了一个等号，变成“18 = age”，那编译器会报错，因为常量（18）不能做左值。关于左值和右值，可以去搜索网上的资料，简单来说“位于赋值运算符两侧的两个值，左边的就叫左值，右边的就叫右值”。

多余的分号（;）

还有一个经常会犯的错误是：在if的括号或者else...if的括号后面多加了一个分号，如下：

if (age == 18);  // 注意这个分号，本来不应该出现的
{
    cout << "你刚成年 !" << endl;
}

上面的代码实际上相当于

if (age == 18)
{
;
}
{
    cout << "你刚成年 !" << endl;
}

看到没有，分号就相当于if语句的大括号里的执行语句，而 ; 是空语句，什么也不执行。我们原先想让其在age等于18时执行的cout语句却成了一个必定会被执行的语句，不论age的值是不是等于18（大括号是可以把多个语句集合起来的分隔区域，可以拿掉大括号再来理解）。

可能有点晕，好好多看几遍代码。

循环

循环是什么呢？

简单地说：循环使你能够重复执行同样的指令。

与 条件语句/条件表达式 类似，循环语句也有几种形式。但是至终，目的仍然是一样的：多次执行同样的指令。

我们一起来看C++中常用的三种循环：

1. while循环

2. do...while循环

3. for循环

这三种循环的基本原理都是一样的，如下图所示：

上图中，依次进行的是：

1. 电脑从上到下执行各条指令，像往常一样

2. 执行完最后一条命令，重新回到第一条命令，从上往下开始执行

3. 如此周而复始

上图中存在的问题是：如果我们不停止循环，那么电脑是有能力一直执行下去的（我一路向北，离开有你的季节。方向盘周围，回转着我的后悔...）。

是的，我们的电脑兄不像有些人，它是从来不抱怨的，叫它干什么就干什么，这也是我们喜欢它的原因。

永不停止的循环有一个术语叫“死循环”，陷入死循环的电脑很容易卡机，这也是程序员经常抱怨的问题之一。

怎么能够让循环停下来呢？

聪明如你应该已经想到了：条件表达式

对了，之前我们学了条件表达式，现在到它派用场的时候了。

事实上，我们创建循环语句的时候，总会给它一个条件，这个条件指明： 在条件为真时，才继续执行循环，否则停止。

下面我么就来看看第一种循环： while循环

while循环

while循环的结构是这样的：

while (/* 条件 */)
{
    // 重复执行的指令
}

不难理解吧，while在英语中是“当...时”，所以就是说：当括号里的“条件”为真时，执行大括号里的指令；一旦条件变为假，则不执行指令，while循环结束。

用一个小程序来看一下吧。这个程序中，我们要让用户输入数字27，只有当用户输入的是27时，程序才会停止，否则会一直让用户输入数字（我知道，我知道，我是很任性）：

#include <iostream>
using namespace std;

int main()
{
    int number = 0;
    
    while (number != 27)
    {
        cout << "请输入 27 ! " ;
        cin >> number;
    }
    
    return 0;
}

运行程序，会如下显示：

请输入 27 ! 10

请输入 27 ! 17

请输入 27 ! 30

请输入 27 ! 27

直到你输入了27，程序才停止。

接下来，我们用while循环来做一点更有意思的事情：让循环执行一定次数

int counter = 0;

while (counter< 10)
{
    cout << "你好!" << endl;
    counter++;
}

它会显示10次 “你好!”，如下：

你好!

你好!

你好!

你好!

你好!

你好!

你好!

你好!

你好!

你好!

逻辑到底是怎么样的呢？

1. counter初始值为0

2. 我们的while循环的循环条件是 counter < 10，也就是说，只有在counter变量的值小于10的时候，才会执行循环体（大括号里）的指令： 打印“你好!”

3. 因为初始counter是0,循环条件为真，所以执行cout，显示“你好!”

4. 在循环体中，我们将counter的值加1

5. 第二次判断条件的时候，counter的值已经是1了，但还是满足counter < 10这个条件，因此再次显示“你好!”

6. 如此这般，一直到counter的值变为10，不满足counter < 10这个条件了，while循环才结束，所以一共打印了十个“你好!”

为了加深理解，我们再来写一个小程序，这次我们让while循环每次输出变量的值：

int counter= 0;

while (counter< 10)
{
    cout << "变量的值是 " << counter << endl;
    counter++;
}

执行程序，显示如下：

变量的值是 0

变量的值是 1

变量的值是 2

变量的值是 3

变量的值是 4

变量的值是 5

变量的值是 6

变量的值是 7

变量的值是 8

变量的值是 9

do...while循环

这种类型和while循环非常类似，不过比较少用到。

与while循环唯一的不同点就是循环条件的位置，while循环中循环条件是在一开始，而do...while循环中是在最后：

int counter = 0;

do
{
    cout << "你好 !" << endl;
    counter++;
} while (counter < 10);

这样的不同改变了什么呢？

很简单，while循环可能会一次也不执行循环体（大括号里）的指令，假如条件一开始就不满足；而do...while循环是先执行循环体的指令，再做条件判断，所以do...while的指令至少会被执行一次

如果我们将do...while循环中的变量counter初始化为40，那么do...while会显示一次“你好!”，对于while循环，如果counter初始为40，那么一次也不会显示“你好!”

for循环

理论上，for循环可以实现我们想要的任何类型循环。

之前已经说过，for循环就是另一种形式而已。

之前while循环的例子：

int counter = 0;

while (counter < 10)
{
    cout << "你好 !" << endl;
    counter++;
}

以上的代码，我么可以写一个for循环的版本，它们做的是同样的事情：

int counter;

for (counter = 0 ; counter < 10 ; counter++)
{    
    cout << "你好 !" << endl;
}

这两个循环都会显示十次 “你好!”

for循环和while循环有什么区别呢？

1. for循环的例子中，counter变量并没有在声明的时候初始化

2. 在for后面的括号中，有更多的东西（下面我们会详述）

3. 在循环体（大括号里的内容）中，没有counter++这个指令

我们最感兴趣的是for后面的括号中的内容，因为那也是for循环吸引人的地方

可以看到括号中有三条指令，用分号（；）分隔：

1. 第一条指令用于初始化：在我们的情况，我们将counter的值初始化为0。
   

2. 第二条指令用于规定条件：和while循环一样，这个条件用于判断循环是否继续执行，当这个条件为真时，for循环才会继续。
   

3. 第三条指令用于做自增：这条指令是在循环体中的指令执行完后才执行的，用于更新变量的值；大多数情况下我们是做自增，当然我们也可以做自减（counter--）或者减少任意值（counter-=2） (关于自增和自减，请看上一课)。

因此，for循环的逻辑是这样的：

1. 括号里的第一句指令用于初始化变量，只会执行一次，之后不再执行。

2. 对括号里的第二句指令做判断，如果条件为真，则执行循环体（大括号里）的指令，如果为假，则不执行循环体，for循环结束。
   

3. 执行完循环体里的指令，接着执行括号里的第三句指令，用于更新变量的值。

4. 再次对括号里的第二句指令做判断，如果条件为真，则执行循环体（大括号里）的指令，如果为假，则不执行循环体，for循环结束。

5. 如此周而复始，注意，括号里的第一句指令只会执行一次，之后就用不上了。
   

简单说来，for循环浓缩了很多内容在for后面的括号里。

一定要熟练掌握for循环，因为以后会很常用。

什么时候用for循环，什么时候用while或do... while循环呢？

并没有规定。

for循环一般用在我们知道循环会执行多少次的情况；而while和do... while循环一般用在希望重复执行指令，直到特定条件满足才停止的情况。

总结

1. 条件表达式使我们可以测试变量的值，根据结果来改变程序的表现。

2. if.. else if... else条件语句是最常用的条件语句。

3. switch条件语句，可以用来测试一个变量的所有可能值。

4. 布尔变量（bool）是一种特殊的变量，它只有两种取值： 真（true）和假（false）。
   

5. 循环语句使我们可以重复相同的指令很多次。

6. 有三种循环语句：while，do... while，for。依情况不同，选择某个循环会更适合。

7. for循环一般用在我们知道循环会执行多少次的情况；而while和do... while循环一般用在希望重复执行指令，直到特定条件满足才停止的情况。
   

第一部分第七课预告

今天的课就到这里，一起加油吧！

下一课我们学习：函数效应，分而治之

本文出自 “程序员联盟 frogoscar” 博客，请务必保留此出处http://4526621.blog.51cto.com/4516621/1737305

【C++探索之旅】第一部分第六课：控制流程，随心所至

标签：条件表达式   循环   c++   程序员联盟   coderunity   

原文地址：http://4526621.blog.51cto.com/4516621/1737305