第3章
CHAPTER 3


语句与控制结构






C++程序由一系列语句组成，这些语句按照一定的控制结构组织起来，按逻辑顺序运行。控制结构包括不同选择分支的计算与处理，以及对相同语句组的循环执行。C++语言提供了判断、循环和转移等语句来控制程序。
学习目标
 掌握if、switch分支语句的使用； 
 掌握for、while、do…while循环语句的使用，并能根据不同要求灵活选择不同的循环语句，熟练使用循环的嵌套； 
 掌握break、continue语句的联系和区别，根据不同场合正确地使用； 
 了解goto语句的转移用法。


3.1语句格式
C++的语句类似于自然语言中的句子，它由不同类型的数据组成。数据类型是程序中最基本的元素，而语句则是程序中可以独立执行的最小单元。C++的语句以分号作为结束标记，相当于自然语言中的句号。语句通常由表达式末尾加上分号构成，C++认为不执行任何操作的空语句是合法的。
例如： 

;//不执行任何操作的空语句

a+b;             //一般表达式语句

a=a+b;           //赋值语句

空语句一般在循环结构中用来延迟一段时间，空语句的分号是必不可少的。分号的存在是语句成立的必要条件。
在C++中，声明变量的语句称为声明语句，声明语句可以出现在程序中任何可以出现语句的地方，这提高了变量声明的灵活性。但是在C语言中，变量的声明不是语句，只能在模块的首部集中声明。
某些情况下，可以用一对花括号将多条语句括起来组成一个块语句。
例如： 

{

int a=6,b=3;

a=(a+b)/2;

cout<<"a="<<a<<endl;

}

块语句的右括号后没有分号，块语句一般存在于选择和循环结构中。
3.2控制结构




C++是解决客观世界实际问题的工具，它对每个具体问题的解决是通过不同算法实现的。例如： 计算1+2+…+100的累加和。

int i=1,sum=0;

for ( i=1;i<=100;i++)

{

sum=sum+i;

}

上例是使用循环结构进行100次累加的算法。算法是解决问题的步骤序列，合法的算法具有如下特征： 
(1) 有穷性： 一个算法必须保证执行有限步之后结束；  
(2) 确定性： 算法的每一步必须有确切的定义，不能出现二义性；  
(3) 输入： 一个算法有0个或多个输入；  
(4) 输出： 一个算法有1个或多个输出，没有输出的算法是毫无意义的；  
(5) 可行性： 算法原则上能够精确地运行。
可以使用多种方法对算法进行描述，如自然语言、流程图、判定表、判定树、伪代码等。其中流程图是使用最广泛的表示方法，它具有简洁、直观、准确的特点，流程图的常用符号如图31所示。


图31流程图的常用符号



C++的控制结构包括顺序结构、选择结构和循环结构。
(1) 顺序结构是最简单的结构，其特点是各个块按照先后次序依次执行。
(2) 选择结构是先对条件进行判断，然后选择执行相应语句。C++的选择结构主要是if语句和switch…case语句。
(3) 循环结构也是先对条件进行判断，然后执行语句，并且在执行完语句后继续进行下一次的条件判断，直到条件为假时才不执行结构中的语句。C++的循环结构主要包括for语句、while语句和do…while语句。
3.3if语句
if语句属于判断选择结构的语句。C++的判断选择结构也称为条件分支结构，一般包括if语句和switch语句。
3.3.1基本if语句
基本if语句是最简单的条件语句，其功能是根据指定的条件判断是否执行相应的语句。其语法格式如下： 

if (条件表达式) 

语句；


其中条件表达式一般是一个关系或者逻辑表达式，其值或者为true，或者为false，并且
必须


图32基本if语句流程


写在一对圆括号中；语句可以是单语句也可以是多条语句组成的语句块(块语句)，多条语句组成的语句块必须包含在一对花括号中，单条语句可以包含在花括号中也可以没有花括号。但是为了程序编写的整洁、规范，建议即使是单语句也将其包含在一对花括号中。
if语句执行过程为： 首先计算条件表达式的值，如果值为true，则执行语句； 否则跳过语句，执行if语句的后继语句，基本if语句流程如图32所示。条件表达式也可以是常量，0表示false,非0表示true。

【例31】从键盘输入学生成绩，如果大于或等于60分，输出“通过”。

1/**************************************************

2程序文件名:Ex3_1.cpp            

3基本if语句的使用                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()



图33例31程序运行结果


8{

9int n;

10cout<<"Please enter the score:"<<endl;


11cin>>n;

12if (n>=60)                                         //条件表达式为n>=60


13{

14cout<<"通过"<<endl;

15}

16}

程序运行结果如图33所示。


例31中的整型变量n用来保存输入的成绩，第12行语句if(n>=60)的判断条件是表达式n>=60，如果成立，则从第13行开始执行语句，输
出“通过”； 否则从第12行直接跳转到第16行。


图34if…else语句流程

3.3.2if…else语句
if…else语句的语法格式如下： 



if (条件表达式) 

语句1；

else

语句2；


其执行过程为： 首先计算条件表达式的值，如果值为true，则执行语句1； 否则执行语句2。if…else语句流程如图34所示。
else前面的部分称为if分支子句,else及其后的部分称为else分支子句； 虽然if分支的语句1和else分支的语句2在形式上是独立的两条语句，但是在语法上，从“if”开始到“语句2； ”结束的整体是一条不可分割if语句。
【例32】从键盘输入学生成绩，如果大于或等于60分，输出“通过”，否则输出“不通过”。

1/**************************************************

2程序文件名:Ex3_2.cpp            

3if…else语句的使用                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{

9int n;

10cout<<"Please enter the score:"<<endl;

11cin>>n;

12if (n>=60)

13{//第13~15行是语句1

14cout<<"通过"<<endl;




图35例32程序运行结果


15}

16else

17{                                      //第17~19行是语句2



18cout<<"不通过"<<endl;

19}  

20}

程序运行结果如图35所示。


在例32中，第13~15行语句块充当了语句1； 第17~19行的语句块充当了语句2。如果条件表达式n>=60成立，则从第13行开始执行语句1，输出“通过”； 否则从第17行开始执行语句2，输出“不通过”。if…else语句中的关键字“else”是必不可少的。
3.3.3嵌套if语句
如果遇到的问题有多重选择，仅使用if语句或if…else语句无法解决。为了解决多重选择问题，C++提供了嵌套的if语句。在if语句中，如果分支子句也是if语句，就构成了嵌套的if语句。
在形式上，嵌套的if语句有两种形式： 一种是嵌套在else分支中，另一种是嵌套在if分支中。
1. else分支的嵌套
else分支嵌套的if语句语法格式为： 

if(条件表达式1)

语句1；

else  if (条件表达式2)

语句2；

…

else  if (条件表达式n)

语句n；

else

语句n+1；

else分支的嵌套图表示如图36所示。



图36else分支的嵌套


【例33】用嵌套if语句将百分制成绩按等级输出。

1/**************************************************

2程序文件名:Ex3_3.cpp            

3嵌套if语句的使用                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{

9int n;                                   //变量n用来存储从键盘输入的成绩

10char grade;

11cout<<"Please enter the score:"<<endl;

12cin>>n;

13if (n<60)

14grade='E';

15else if(n<70)

16grade='D';

17else if(n<80)

18grade='C';

19else if(n<90)

20grade='B';

21else if(n<=100)

22grade='A';

23else

24grade='F';

25cout<<"The grade is "<<grade<<endl;

26}

在例33中，首先在第13行判断关系表达式n<60，如果结果为真，则执行第14行，把字符‘E’赋给grade，然后跳过其他语句，直接执行第25行的语句。这种嵌套的if语句，只允许选择满足条件的一个分支，其他分支不再判断执行。如果第13行结果为假，也就是n≥60,则跳过第14行而执行第15行的判断。第24行表示如果输入的成绩大于100，grade的值为'F'。
2. if分支的嵌套
if分支嵌套的if语句语法格式为： 


if(条件表达式1)

if (条件表达式2)

语句1；

else

语句2；

else

语句3；

if分支的嵌套图如图37所示。


图37if分支的嵌套图



使用if分支的嵌套形式修改例33中相应的语句为： 

if (n>=60)

if(n>=70)

if(n>=80)

if(n>=90)

grade='A';

else

grade='B';

else

grade='C';

else

grade='D';

else

grade='E';

在使用if分支嵌套时，要注意else与if的匹配原则： else与上方离它最近的未匹配过的if相匹配。
3.3.4条件运算符
当if…else语句是简单语句时，可用条件运算符“？： ”来进行简化，其语法格式为： 

(条件表达式)？语句1： 语句2

例如，求两个数a和b中较大的值，使用if语句： 

if(a>b)                                   

max=a;                                                //语句1

else

  max=b;                                                //语句2

将if语句替换成等价的条件运算符为： 

max=(a>b)?a:b;

3.4switch语句
嵌套的if语句能够实现多分支选择，C++还提供了另外一种实现多分支选择的结构——switch语句。switch语句也称为开关语句，它根据给定的条件，从多个分支中选择一条语句作为执行的入口。switch语句虽然与嵌套的if语句功能类似，但是switch语句每次都计算同一表达式的值，而嵌套的if语句要分别计算各个if分支语句表达式的值，所以在处理多分支选择问题时，switch语句更加简便、直观。其语法格式如下： 

switch(表达式) 

{

case 常量表达式1：［语句块1；］［break；］

case 常量表达式2：［语句块2；］［break；］

…

case 常量表达式n：［语句块n；］［break；］

［default:语句块n+1；］

}

（1） switch后面圆括号中的“表达式”只能是整型、字符型、枚举型或布尔型等离散类型，而不能是实型(float、double型)等连续类型。
（2） “case”起到标号的作用，其后“常量表达式”的类型必须与“表达式”的类型匹配，并且所有case后常量表达式的值不能重复。
（3） 当“表达式”的值与某一个case后“常量表达式”的值相等时，就执行这个case后的语句； 如果所有case后“常量表达式”的值都不与“表达式”的值匹配时，就执行“default”后的语句。
（4） 符号“［ ］”表示其中的内容是可选的； 语句块、break和default都是可选的，语句块由一条语句或者一个复合语句组成。
switch语句的执行过程为： 
① 计算switch后表达式的值； 
② 将表达式的值依次与case后常量表达式的值相比较，如果表达式的值与某一常量表达式的值相等，则执行该case后的语句块，直到遇到break或switch语句的右花括号； 
③ 如果表达式的值与case后所有常量表达式的值都不相等，则执行default后的语句； 如果switch语句不包含default,则不执行任何操作。
【例34】用switch语句将百分制成绩按等级输出。

1/**************************************************

2程序文件名:Ex3_4.cpp            

3switch语句的使用                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{

9int n;

10cout<<"Please enter the score:"<<endl;

11cin>>n;

12switch (n/10)

13{

14case 10:

15cout<<"The grade is A"<<endl;

16break;

17case 9:

18cout<<"The grade is A"<<endl;

19break;

20case 8:

21cout<<"The grade is B"<<endl;

22break;

23case 7:

24cout<<"The grade is C"<<endl;

25break;

26case 6:

27cout<<"The grade is C"<<endl;



图38例34运行结果


28break;

29default:

30cout<<"The grade is D"<<endl;

31}

32}

程序运行结果如图38所示。


上例中，当n/10的值为10或9时，case后的语句相同，输出等级都是"A"; 同样，当n/10的值为7或6时，case后的语句也相同，输出等级都是"C"。C++规定，当多个case共用相同语句时，可以对相同语句进行简化处理，如例34中的第14~19行代码可替换为： 

case 10:

case 9:

cout<<"The grade is A"<<endl;

同理，第23~27行代码也可替换为： 

case 7:

case 6:

cout<<"The grade is C"<<endl;

但是下面写法是错误的： 

case 10， 9:

cout<<"The grade is A"<<endl;

如果switch语句中case标号后省略了break，则程序会从第1个匹配的case开始不加判断地执行switch语句中剩下的所有语句，直到遇到第1个break为止。例如： 

1switch(a)

2{

3case'A'：

4cout<<" It is A"<<endl;

5case 'B':

6cout<<" It is B"<<endl;

7case'C':

8cout<<" It is C"<<endl;

9break;

10default:

11cout<<" It is D"<<endl; 

当字符变量a的值为'B'时，程序的执行结果为：

It is B

It is C

如果去掉第9行的break;则程序的结果变为：

It is B

It is C

It is D

3.5for循环语句
在C++程序中，常常会出现在满足给定条件下，需要重复执行相同操作的情况。这种重复执行相同的操作就是循环，C++提供了3种实现循环的语句： for语句、while语句和do…while语句。在循环语句中，被重复执行的操作叫作循环体，循环体可以由一条语句组成，也可以由一个语句块或空语句组成。
3.5.1for语句
for语句的语法格式如下： 

for(表达式1；表达式2；表达式3)

循环体



图39for语句流程

其中，for是关键字； 表达式1用来给循环变量赋初值，表达式1在循环变量中仅执行一次； 表达式2是循环继续进行的条件； 表达式3是对循环变量的值进行修改。

for语句的执行过程为： 
① 计算表达式1的值； 
② 计算表达式2的值，如果值为false或0，则结束循环，转到⑥； 
③ 如果表达式2的值为true或非0，则执行循环体； 


④ 计算表达式3的值； 
⑤ 转到②； 
⑥ 执行for语句的后续语句。

for语句流程如图39所示。



for语句不仅可以用于循环次数确定的情况，还可以用于循环次数虽不确定但给出了循环继续条件的情况。
【例35】用for语句计算1+2+3+…+100。

1/**************************************************

2程序文件名:Ex3_5.cpp            

3for语句计算1+2+3+…+100                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{ 

9int i,sum=0;// 将累加变量sum初始化为0

10for(i=1; i<=100; i++)             // i为循环变量，循环次数为100

11{

12sum += i;                       // 实现累加

13}



图310例35运行结果

14cout<<"sum= "<<sum<<endl;

15}

程序运行结果如图310所示。



根据程序的不同要求，对for语句中的表达式可以进行相应默认。
(1) 表达式1可以默认。由于表达式1的作用是给循环变量赋初值，所以若默认表达式1，则应在for语句之前有给循环变量赋初值的语句。虽然默认表达式1，但是其后的分号不能默认。
例如： 

int a=0；

for( ； a<100 ； a++) //默认表达式1，但分号必须保留

sum+=a；

(2) 表达式2可以默认。表达式2的作用是判断循环继续进行的条件，若默认表达式2，则循环会无条件永远进行下去。虽然默认表达式2，但是其后的分号同样不能默认。

例如： 

for(a=0； ；a++)                    //默认表达式2，但分号必须保留

 sum+=a；

等价于： 

for(a=0；1 ；a++)                   //默认表达式2相当于循环条件永远为真

 sum+=a；

(3) 表达式3可以默认。表达式3的作用是对循环变量进行修改，因此若默认表达式3，则在每次循环结束后，应该有对循环变量进行修改的语句，否则循环一旦开始运行则永远无法正常结束。
例如： 

for(a=0；a<100 ； )                  //默认表达式3，循环变量的值永远为0，程序将永远进行下去

sum+=a；                         

若默认表达式3并让程序能够正常结束，则需要添加如下修改循环变量的语句： 

for(a=0；a<100 ； )                  

{

sum+=a；                          

a++；                             //使循环变量a自增1

for语句不但可以默认3个表达式中的一个，而且可以同时默认3个表达式中的任意两个，C++认为最极端的同时默认3个表达式的写法也是合法的。不管表达式默认与否，for语句圆括号中的两个分号缺一不可。
3.5.2for语句的循环嵌套
在一个循环中又包含其他循环的结构称为循环嵌套。for语句可以实现循环嵌套。
【例36】用for语句实现在屏幕上输出以下图案：

*

* * *

* * * * *

* * * * * * *

1/**************************************************

2程序文件名:Ex3_6.cpp            

3for语句实现循环嵌套                   

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{

9int i,j,k;

10for (i=0;i<=3;i++)                    //外重循环，循环4次，显示4行

11{

12for (j=0;j<=2-i;j++)               //内重循环

13{

14cout<<"  ";

15}

16for (k=0;k<=2*i;k++)               //内重循环

17{	

18cout<<" *";

19}

20cout<<"＼n";                      //外重循环中的语句

21}

22}

【程序解释】
(1) 在例36中，共有两重循环嵌套，第10行的for语句对应的是外重循环，主要控制对应图案显示的行数。
(2) 第12行和第16行的for语句对应的都是内重循环，分别显示每一行的空格符和“*”。
(3)第20行是外重循环的语句，用来实现每行输出结束后换行，其中“＼n”的作用和endl的作用完全相同。

3.6while循环语句
3.6.1while语句

while循环语句也称为当型循环，当满足判断条件，则执行循环； 语句的语法格式如下： 

while(条件表达式)

循环体

其中，while是关键字； 条件表达式是C++中的一个合法表达式，表示是否执行循环体的判断条件。循环体可以是一条语句，也可以是复合语句。如果循环体是一条语句，则其两边有无花括号皆可； 如果循环体是复合语句，则复合语句必须被包含在一组花括号中。


图311while语句流程


while语句的执行过程为： 


① 计算条件表达式的值，如果值为false或0，则结束循环，转到④； 
② 如果条件表达式的值为true或非0，则执行循环体； 
③ 转到①； 
④ 执行while语句的后续语句。

while语句流程如图311所示。

【例37】用while语句计算1+2+3+…+100。

1/**************************************************

2程序文件名:Ex3_7.cpp            

3while语句计算1+2+3+…+100                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{ 

9int i=1,sum=0; 		     

10while(i<=100)                        // 判断i<100是否成立

11{

12sum += i;                          // 实现累加

13i++;

14}



图312例37运行结果

15cout<<"sum= "<<sum<<endl;

16}

程序运行结果如图312所示。


（1） 对比例35和例37可以看出，while前“i=1”的作用相当于for语句的表达式1，用来给循环变量赋初值。
（2） while语句中条件表达式“i<=100”的作用相当于for语句的表达式2。
（3） while语句中“i++”的作用相当于for语句的表达式3，用来修改循环变量。
（4） while语句和for语句可以相互替换使用。
3.6.2do…while语句
do…while循环语句也称为直到型循环，语句的语法格式如下： 

do

循环体

while(条件表达式)；

其中，do和while都是关键字； 循环体可以是一条语句，也可以是复合语句； 条件表达式是C++中的一个合法表达式，给出是否继续执行循环体的判断条件。
do…while语句的执行过程为： 
① 执行循环体； 
② 计算条件表达式的值，如果值为false或0，则结束循环，转到④； 
③ 如果条件表达式的值为true或非0，则转到①； 
④ 执行do…while语句的后续语句。

do…while语句流程如图313所示。


图313do…while语句流程


【例38】用do…while语句计算1+2+3+…+100。

1/**************************************************

2程序文件名:Ex3_8.cpp            

3do…while语句计算1+2+3+…+100                    

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{ 

9int i=1,sum=0; 		       

10do                                // 不判断条件，先执行一次循环体

11{

12sum += i;                       // 实现累加

13i++;

14} while(i<=100);                  //判断i<=100是否成立,分号不能漏掉



图314例38运行结果

15cout<<"sum= "<<sum<<endl;

16}

程序运行结果如图314所示。


（1） 对比do…while语句和for语句、while语句可以看出，不管条件表达式是否成立，do…
while语句中循环体最少执行次数为1，而for语句和while语句的最少执行次数为0。
（2） do…while语句条件表达式后的分号一定不能漏掉。
3.7转移语句
C++语言提供了一些用以改变程序中语句执行顺序的转移语句，转移语句能够使程序从某一条语句有目的地转移到另一条语句执行。常用的转移语句有break语句、continue语句和goto语句。其中break语句和continue语句是半结构化的控制语句，goto语句是非结构化的控制语句。
3.7.1break语句
break语句用在switch语句和所有循环语句中。
break语句在switch语句中，用来跳出switch语句，继续执行switch后的语句； 在循环语句中，用来跳出包含它的最内层循环体。例如，下面的代码在执行了break语句后，继续执行“sum=100”处的语句，而不是跳出所有循环： 

for(i=0;i<100;i++)

{

for(j=0;j<i;j++)

{

if(j>100)

{

break;

}

sum+=j;

}

sum=100;

}

【例39】输出10~100的全部素数(素数i是指除1和i之外，不能被2~(i-1)的任何整数整除的数)。

1/**************************************************

2程序文件名:Ex3_9.cpp            

3输出10~100的全部素数                    

4**************************************************/

5#include <iostream>

6using namespace std;  

7main()

8{ 

9int i=11, j, counter=0; 

10for( ; i<=100; i+=2)//外循环：为内循环提供一个整数i

11{ 

12for(j=2; j<=i-1; j++)    	  //内循环：判断整数i是否是素数

13{

14if(i%j==0) 	          //i不是素数：因为能被2~(i-1)的某个数整除

15break;                   //强行结束内循环，执行第17行语句

16}      

17if(counter%10==0)         	  //输出10个数后换行

18cout<<"＼n";                  //换行 

19if(j >= i) 		              //整数i是素数：输出后计数器加1

20{

21cout<<"   "<<i; 

22counter++;

23}

24}

25cout<<"＼n";

26}

程序运行结果如图315所示。


图315例39运行结果


【程序解释】
（1） 在例39中，共有两重循环嵌套，第10行的for语句对应外重循环，第12行的for语句对应内重循环。
（2） 当执行到第15行的break时，跳出内重循环，继续执行第17行。
3.7.2continue语句
continue语句仅用在循环语句中。
continue语句的功能是从包含continue的最内层循环体的当前位置，跳过循环体中本次循环尚未执行的语句，接着进行下一次是否执行循环的判定。也可以这样理解： 在循环体中如果遇到了continue语句，则立即结束循环体的本次循环，接着开始下一次循环的判定。
例如： 

1for(int  i=100;i<=200;i++) 

2{

3if(i%3==0)                    //判断i能否被3整除

4continue;

5cout<<i<<endl;

6}

这段代码用来输出100~200所有不能被3整除的整数。

其执行过程为： 
① 判断表达式2(即i<=200)是否成立； 
② 如果值为false或0，则结束循环，转到⑧； 
③ 如果值为true或非0，则转到④； 
④ 判断“i%3==0”是否成立，如果不成立，转到⑤，否则转到⑥； 
⑤ 执行第5行，转到⑦； 
⑥ 执行第4行“continue”，转到⑦； 
⑦ 计算表达式3(即i++)的值，转到①； 
⑧ 执行for的后续语句。
continue语句与break语句的区别是： 遇到continue语句，立即结束本次循环，但不终止包含它的整个循环； 遇到break语句则立即结束循环，并且终止包含它的整个循环。
3.7.3goto语句
goto语句使程序跳转到语句标号所指的位置开始执行，其格式如下： 

goto  语句标号；

语句标号属于标识符，其形式如下： 

语句标号： 语句

这里的语句可以是任何语句，如while语句、for语句等。
在C++中。goto语句只能用在函数体。在同一函数体中，语句标号应该是唯一的。例如： 

i=1,sum=0;

wen: sum+=i;

if(i<=100)

 goto wen;

cout<<"sum is"<<sum<endl;

编译器遇到了goto语句会无条件地转向语句标号后的语句。但是在循环语句中，只能利用goto语句从循环体内跳出，而不能从循环体外跳到循环体内。
3.8实例应用与剖析
【例310】输出100~200所有不能被3整除也不能被7整除的整数。

1/**************************************************

2程序文件名:Ex3_10.cpp           

3for语句求素数                

4**************************************************/

5#include<iostream>

6using namespace std;

7main()

8{

9cout<<"100~200不能被3和7整除的数为＼n";

10for(int i=100;i<=200;i++)

11{

12if(i%3!=0&&i%7!=0)

13cout<<i<<"     ";

14}

15cout<<"＼n";

16}

程序运行结果如图316所示。



图316例310运行结果


【程序解释】
（1） 第10行使用了for语句，表达式1“int i=100”在定义循环变量i的同时给其赋初值100。
（2） for语句从第10行开始，到第14行结束，循环体循环201次。


视频


【例311】中国古代数学史上著名的百钱买百鸡问题： “今有鸡翁一，值钱五； 鸡婆一，值钱三，鸡雏三，值钱一。凡百钱买鸡百只，问鸡翁、鸡婆、鸡雏各几何？”

1/**************************************************

2程序文件名:Ex3_11.cpp           

3嵌套for语句计算百钱买百鸡问题                 

4**************************************************/

5#include<iostream>

6using namespace std;

7main()

8{

9int cock,hen,chick;

10cout<<"  鸡翁     鸡婆     鸡雏"<<endl;

11for(cock=0;cock<=20;cock++)

12for(hen=0;hen<=33;hen++)

13{

14chick=100-cock-hen;

15if(cock*5+hen*3+chick/3==100 && chick%3==0)

16cout<<"    "<<cock<<"       "<<hen<<"       "<<chick<<endl;



图317例311运行结果

17}

18}

程序运行结果如图317所示。

【程序解释】
（1） 这是双重for循环嵌套问题。
（2） 由cock+hen+chick=100和5*cock+3*hen+chick/3=100可知，百钱最多能买鸡翁20只或鸡婆33只,这与第11行和第12行的两个循环继续条件相对应。
（3） 第15行的判断条件为鸡翁、鸡婆和鸡雏的总和为100，并且鸡雏的数目要被3整除。
【例312】编写程序，从键盘输入一个整数，逆向输出其各位数字，同时求出其位数以及各位数字之和。

1/**************************************************

2程序文件名:Ex3_12.cpp           

3while语句求逆序问题                 

4**************************************************/

5#include <iostream>

6using namespace std;

7main()

8{

9int num,sum=0,k,i=0;

10cout<<"请输入一个整数:";

11cin>>num;

12cout<<"逆序为：";

13while(num>0)

14{

15k=num%10;

16cout<<k;

17sum+=k;

18i++;

19num/=10;

20}



图318例312运行结果

21cout<<"＼n各个位数数字之和为："<<sum<<endl;

22cout<<"你输入的是："<<i<<<" 位数"<<endl;

23}

程序运行结果如图318所示。


【程序解释】
（1） 根据提示输入整数，如“635214”，编译器会自动生成逆序“412536”以及各位数字之
和“21”。
（2） num存储被输入的整数； 第15行“k=num%10”，表示每次循环时，k变量的值是num的
个位数字。
（3） 每次循环结束后，num=num/10，使编译器能够依次获取每位数字； 编译器将每次获取的个位数字输出，其输出的组合便是原数字的逆序。
（4） 变量sum的作用是将每次循环计算得到的k值相加，所得结果便是各位数字之和，循环的次数便是输入数字的位数。
3．9建模扩展与优化
【例313】基于例311的百钱买百鸡问题进行扩展如下： 鸡翁一，值钱五； 鸡婆一，值钱三，鸡雏三，值钱一。凡n钱买鸡n只，问鸡翁、鸡婆、鸡雏各几何？

1/**************************************************/

2程序文件名:Ex3_13.cpp            

3降低时间复杂度计算n钱买n鸡问题                    

4/**************************************************/

5#include <bits/stdc++.h>

6using namespace std;

7main(){

8int n,cock,hen,chick,s=0;

9cout<<"请输入钱数:";

10cin>>n;

11for(cock=0; cock<=n/5;cock++)

12{

13hen=(n-7*cock)/4;

14chick=n-cock-hen;

15if (5*cock+3*hen+chick/3==n&&chick%3==0)

16{

17if (hen >= 0 && cock>=0)

18{

19s++;

20cout<<"鸡翁"<<cock<<"只"<<" 鸡母"<<hen<<"只 鸡雏"<<chick<<"只"<<endl;

21}

22}

23} 

24if(s==0)

25{

26cout<<"无解";

27}

28else

29{

30cout<<endl<<"共有"<<s<<"种方案组合"<<endl;

31}

32}

程序运行结果如图319所示。


图319例313运行结果


【程序解释】
（1） 例311的时间复杂度为O(n2),本题将时间复杂度降低为O(n)。
（2） 第5行导入万能头文件stdc++．h。
（3） 设鸡翁cock只，鸡婆hen只，则鸡雏chick=n-cock-hen只，可得到方程： 
5*cock+3*hen+(n-cock-hen)/3=n。
（4）  第11~23行，用一层循环来枚举鸡翁数量cock。
（5）  第14行计算鸡母数量为hen=(n-7*cock)/4，则第17行只需判断鸡雏、鸡婆个数是否为非负数即可。
思考： 
在使用多重循环求解问题时，如何减少循环嵌套数量进行枚举，以降低时间复杂度。
【例314】一诺是小动物保护协会成员，她在家里养了n只兔子，除去生病和走失的情况，兔子的数量每个月以1．72倍的速度递增。请计算k个月后，一诺家共有多少只兔子？(如果计算出的数字是小数，则小数部分按照一只进行计算。)

1/**************************************************/

2程序文件名:Ex3_14.cpp

3兔子繁殖问题

4/**************************************************/

5#include <iostream>

6#include <cmath>

7using namespace std;

8main( )

9{

10int n,k;

11cout<<"请输入兔子初始数量n：";

12cin>>n;

13cout<<"请输入经历的月数k：";

14cin>>k;

15double s=1.0*n;

16for (int i=1;i<=k;i++)

17{ 

18s=s*1.72;

19}

20cout<<"经过"<<k<<"个月后，兔子的数量变为"<<ceil(s)<<"只"<<endl;

21}

程序运行结果如图320所示。


图320例314运行结果


【程序解释】
（1） 初始兔子数量1<n≤10，月份0<k≤12。
（2） 经过k月后，经过1．72倍递增后的值可能包含小数部分，故第15行中数量s的数据类型定义为double。
（3） 第20行ceil()是取整函数，返回大于等于s的最小整数。 
小结
(1) 在表达式后添加分号构成语句； 语句包括单语句和块语句，若干语句通过{}组成块语句。
(2)  if语句是最简单的判断控制语句，包括if和if…else两种基本形式，简单的if…else语句可以与条件运算符相互替换使用。
(3)  switch…case语句常用来解决多重选择分支问题，使程序的结构更加清晰； case语句可以有不同的精简表示形式，与break语句结合使用。
(4)  C++的循环语句包括for语句、while语句和do…while语句， for语句通常可与while语句互相替换。当循环次数不确定时，常使用while语句； 当循环次数不确定且循环体至少执行一次时，常使用do…while语句； 当循环次数已知时，常使用for语句。for语句的3个表达式有不同的功能，在某些情况下可以缺省，但是表达式间的分号必须保留。
(5)  C++语言提供3种转移语句，其中break语句在switch语句和循环语句中，用以结束switch语句或其所在的最内层循环体； continue语句仅在循环语句中使用，用以其所在循环体的本次循环继续进行下一次循环，建议尽量少使用goto语句。
习题3
1. 选择题
(1) 下列正确的if语句是()。

A.   if(1<=m<=n)m++;
B.   if(m==n) m++;
C.   if(m<n) {m++ n++;}
D.   if(m!=n) cout<<m;else cout<<n;
(2) 下列程序的输出结果是()。

main()

{ 

int a(24),b(35),c(46);

if(a>b)

a=b; b=c; c=a; 

cout<<"a="<<a<<",b="<<b<<",c="<<c;

}

A.   a=24,b=35,c=46B.  a=24,b=46,c=24
C.  a=35,b=46,c=24D.  a=35,b=46,c=35
(3) 下列程序段的输出结果是()。

int i(2),j(3), k(9), m(8), n(7);

if (i<j)

if(k<m) 

n=1;

else if(i<k)

if(j<m) 

n=6;

else n=3;

else n=7;

else n=11;

cout<<n;

A.   3B. 6C.  7D.  11
(4) 下列程序的输出结果是()。

main()

{

int i(0),j(0),k(1);

switch(k)

{

case 0:j++;

case 1:i++;

case 2:i++;j++;

}

cout<<"i="<<i<<"j="<<j;

}

A.   i=2,j=2B.  i=1,j=1C.  i=1,j=0D.  i=2,j=1
(5)  j=(i>0?1： i<0?-1： 0);的功能等同于下列哪个if语句？()
A.  j=-1;

if(i)

if(i>0) j=1;

else if(i==0) j=0;

else j=-1;B.  if(i)

if(i>0) j=1;

else if(i<0) j=-1;
C.  if(i>0) j=1;

else if(i<0) j=-1;

else j=0;D.  j=0;

if(i>=0)

if(i>0) j=1;

else j=-1;
(6) 下列程序段的结果是()。

int i(1),j(10) ;

do

{

j-=i;i++;

}while(j-- >=9);

cout<<i<<","<<j;

A．  i=3,j=11B． i=3,j=5C． i=1,j=-1D． i=4,j=9
(7) 下列的程序段循环了多少次？()

int k=10;

while (k=3)

k=k-1;

A.   0次B.  3次C.  7次D. 死循环
(8) 下列与“for(式1； 式2； 式3； )循环体； ”功能相同的语句是()。
A.  式1； while(式2){循环体； 式3； }
B.  式1； while(式2){式3； 循环体； }
C.  式1； do{循环体； 式3； } while(式2)
D.   do{式1； 循环体； 式3； } while(式2)
(9) 下列循环执行的次数是()。

for(int x=0,y=0;(y=1)&&(x<3);x++)

A.   1次B.  2次C.  3次D.  4次
(10) 下列程序段的运行结果是()。

int i(2),j(1);

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

{

if(j>=10) break;

if(j%3==1)

{

j+=3; 

continue;

}

i=i+1; 

}

cout<<i;

A.   101B. 6C.  5D.  4
2. 编程题
(1) 求sn=a+aa+aaa+…+aa…aa(n个a)之值，其中a是一个数字(例如： 3+33+333+3333，此时n=4,n由键盘输入)。
(2) 从键盘输入一个整数，判断该数是否为回文数（所谓回文数就是从左向右读和从右向左读一样的数，如7887、23432）。
(3) 编写程序，分别正向、逆向输出26个大写英文字母。
3. 读程序写结果。
(1) 

#include<iostream>                    

using namespace std;

int sum,k;

main()

{

for(sum=0,k=1;k<10;k++)

{

if(k%2==0)

continue;

sum+=k;

}

cout<<"sum="<<sum<<endl;

}

(2) 
#include <iostream>

using namespace std;

main()

{

int a(18),b(21),m(0);

switch(a%3)

{

case 0: m++;break;

case 1: m++;

switch(b%2)

{

default: m++;

case 0: m++;break;

}

}

cout<<m;

}