**这是本文档旧的修订版!**
本页对应教材第 4 章《逻辑思维与编程思路》(PDF 第 55~90 页,即书 P34~P68,章首页无页码)。上机环境换成 **Linux 终端 + g++**:每个例题都给出可以直接编译运行的完整代码和运行结果,教材里"建工程、按运行键"的步骤,这里一律用 `g++ -o 程序名 源文件.cpp` 加 `./程序名` 两条命令代替。
教学目标与内容要点
教学目标
- 将实际问题抽象为逻辑关系
- 枚举法解题思路
- 关系运算符与关系表达式
- 逻辑运算符与逻辑表达式
- 程序的循环语句与分支语句
内容要点
- 关系运算符与关系表达式
- 逻辑运算符与逻辑表达式
- 从人的思维到计算机语言的表示
- 枚举的概念与思路
- 循环结构(for)
- 分支结构(if…else)
- break 和 continue
贯穿全章的任务 4.1
警察抓到 A、B、C、D 四个罪犯,在审问他们谁是主谋时:A 说“不是我”,B 说“是 C”,C 说“是 D”,D 说“他胡说”。已知只有一个人是主谋、三个人说的是真话、一个人说的是假话,请编程序找出真正的主谋。
4.1 关系运算和关系表达式
4.1.1 关系运算符
C++ 中有 6 个关系运算符:
>=大于等于>大于==等于<=小于等于<小于!=不等于
【例题 4.1】验证关系运算符(对应教材程序 4_1.cpp):
// 程序名:rel_op.cpp // 主要功能:验证关系运算符 #include <iostream> using namespace std; int main() { cout << "3>2 的逻辑值是:" << (3 > 2) << ",1 为真,0 为假。" << endl; cout << "3>=2 的逻辑值是:" << (3 >= 2) << ",1 为真,0 为假。" << endl; cout << "3==2 的逻辑值是:" << (3 == 2) << ",1 为真,0 为假。" << endl; cout << "3<2 的逻辑值是:" << (3 < 2) << ",1 为真,0 为假。" << endl; cout << "3<=2 的逻辑值是:" << (3 <= 2) << ",1 为真,0 为假。" << endl; cout << "3!=2 的逻辑值是:" << (3 != 2) << ",1 为真,0 为假。" << endl; return 0; }
编译运行:
$ g++ -o rel_op rel_op.cpp $ ./rel_op 3>2 的逻辑值是:1,1 为真,0 为假。 3>=2 的逻辑值是:1,1 为真,0 为假。 3==2 的逻辑值是:0,1 为真,0 为假。 3<2 的逻辑值是:0,1 为真,0 为假。 3<=2 的逻辑值是:0,1 为真,0 为假。 3!=2 的逻辑值是:1,1 为真,0 为假。
- 注意每个关系表达式外面都套了一对圆括号。因为
<<的优先级高于关系运算符,写成cout << 3>2;会被理解成(cout << 3) > 2,输出结果就不对了 - 别把
=(赋值)和==(等于)搞混,这是最常见的错误之一
【类似练习】把例题 4.1 里的常数 3、2 换成从键盘读入的两个整数,一次输出 6 个关系表达式的值。
4.1.2 关系表达式的一般格式
- 一般格式:
<变量1> 关系运算符 <变量2>,例如变量 1 为 b、变量 2 为 c、关系运算符为>,则关系表达式为b > c - 关系表达式的值只有两种:真(即 1 或非零)、假(即 0)
- 关系运算符两侧可以是常量、变量或表达式,但比较的是“值”,例如
a + b > c是先算出 a+b 的值再与 c 比较
4.1.3 将"是"和"否"写成关系表达式
要完成任务 4.1,先把 4 个人说的话写成关系表达式。为此定义一个字符型变量 head,表示要找的主谋:
char head = ' '; // 定义字符型变量并初始化为空
约定:== 在这里表示“是”,!= 在这里表示“不是”。于是 4 个人说的话可以写成表 4.1 的形式。
表 4.1 使用关系表达式来表示 4 个罪犯所说的话
| 罪犯 | 说的话 | 关系表达式 | 罪犯 | 说的话 | 关系表达式 |
|---|---|---|---|---|---|
| A | “不是我” | head != 'A' | C | “是 D” | head == 'D' |
| B | “是 C” | head == 'C' | D | “他胡说” | head != 'D' |
字符在存储单元中是以 ASCII 码的形式存放的('A' 的 ASCII 码为 65)。所以以 head 为标识的存储单元中存的是数字 65。
【例题 4.2】验证 'A' 和 65 是否相等(对应教材程序 4_2.cpp):
// 程序名:ascii.cpp // 主要功能:验证 'A' 和 65 是否相等 #include <iostream> using namespace std; int main() { char head; head = 'A'; // 将 head 赋值为 'A' cout << "65=='A' 关系表达式的值为 " << (65 == 'A') << endl; return 0; }
运行结果:
$ g++ -o ascii ascii.cpp $ ./ascii 65=='A' 关系表达式的值为 1
- Linux 下
char同样是 1 字节、同样用 ASCII 码存放英文字符,所以字符与整数的关系跟教材完全一致 - 想亲眼看看某个字符的编码,可以写
cout << (int)'a' << endl;(输出 97),或在终端里执行man ascii
4.2 枚举法的思路
设主谋用 1 表示、从犯用 0 表示,A、B、C、D 中只有一个是主谋,就有教材表 4.2 所示的 4 种状态;由于已经设主谋为 head,这 4 种状态可以简化成表 4.3 的形式。
表 4.3 4 种状态的简化形式
| 状态 | 赋值表达式 | 状态 | 赋值表达式 |
|---|---|---|---|
| 1 | head = 'A' | 3 | head = 'C' |
| 2 | head = 'B' | 4 | head = 'D' |
所谓枚举,就是按照这 4 种假定逐一去测试 4 个人的话里有几句是真话;如果不满足 3 句为真,就否定这一假定,换下一个状态再试。
具体做法如下:
- 假定
head='A'代入 4 句话,4 个关系表达式逻辑值的和为 1,显然 A 不是主谋(教材表 4.4) - 假定
head='B'代入 4 句话,和为 2,显然 B 不是主谋(教材表 4.5) - 假定
head='C'代入 4 句话,和为 3,C 就是主谋(教材表 4.6)
一个罪犯一个罪犯地去试,就是枚举。从写程序的角度看,实现枚举最好用循环结构。
4.3 循环结构
循环结构是程序中用得最多的一种语法结构,它发挥了计算机擅长重复运算的特点。
4.3.1 使用循环结构的部分程序
结合任务 4.1,用循环把“逐个假定、统计真话”这件事交给计算机去做:
for (k = 1; k <= 4; k = k + 1) // 计数型循环,循环的控制变量为 k { head = 64 + k; // 产生被试者,依次为 'A'、'B'、'C'、'D' sum = (head != 'A') // 测试 A 的话是否为真 + (head == 'C') // 测试 B 的话是否为真 + (head == 'D') // 测试 C 的话是否为真 + (head != 'D'); // 测试 D 的话是否为真 }
64 + k就是被试者的 ASCII 码:k 为 1 时 head 是 'A',k 为 4 时 head 是 'D'- 关系表达式的值正好是 1 或 0,把它们加起来,和就是“真话的句数”
4.3.2 for 语句的格式与执行过程
for (表达式1; 表达式2; 表达式3) { 循环体语句组; }
为了更好理解,三个表达式也可以写成:for (初始化循环变量; 循环条件判断; 修改循环变量的值)。
执行过程(教材图 4.2):
- ① 求解表达式 1,给循环控制变量置初值(这是一条赋值语句)
- ② 判断表达式 2,看是否未到终值(条件判断语句):为真则执行 ③,为假则转 ⑤ 退出循环
- ③ 执行循环体语句组,之后转 ④
- ④ 求解表达式 3,让循环控制变量增(减)值,再转 ②
- ⑤ 退出循环,执行 for 的下一条语句
- 循环体里若有多条语句(复合语句),必须用一对大括号括起来,否则会出现语法错误或逻辑错误。有经验的程序员在每次输入复合语句之前,先输入左右两个大括号
- 教材用 N-S 程序框图(图 4.3)表示 for 结构:三个表达式写在上方,循环体画成放在右下角的小矩形
4.3.3 使用 for 循环解题实例
【任务 4.2】试编一程序求自然数 1~100 之和。
解题思路:通过 for 循环把 1~100 逐个表示出来,在每次表示出来的同时做 sum = sum + i,就实现了由 1 至 100 的累加。
【例题 4.3】求 1~100 之和(对应教材程序 4_3.cpp):
// 程序名:sum100.cpp // 主要功能:求自然数 1~100 之和 #include <iostream> using namespace std; int main() { int i = 0, sum = 0; // 声明 i、sum 为整型变量,并初始化为 0 for (i = 1; i <= 100; i = i + 1) // for 循环 { sum = sum + i; // 累加求和 } cout << "自然数 1~100 之和为:" << sum << endl; return 0; }
运行结果:
$ g++ -o sum100 sum100.cpp $ ./sum100 自然数 1~100 之和为:5050
两个思考题:
- 把
for (i=1; i<=100; i=i+1)改成i=i+2,求的是哪些自然数之和?答:奇数 1、3、5、…、99,结果是 2500 - 改成
i<=100000还能得出正确结果吗?答:不能。1~100000 之和是 5000050000,超过了 int 的表示范围(Linux 下 int 为 4 字节,最大 2147483647),会发生溢出;把 sum 声明为long long(8 字节)即可正确计算
【任务 4.3】试编一程序输出 9×9 口诀表。
解题思路:乘法口诀表是一个二维表,行号为 i(1~9),列号为 j(1~9),第 i 行有 i 个式子。输出它需要用一重对行、一重对列的两重 for 循环。
【例题 4.4】输出 9×9 口诀表(对应教材程序 4_3.cpp):
// 程序名:table99.cpp // 主要功能:输出 9×9 口诀表 #include <iostream> #include <iomanip> // Linux 下使用 setw 必须包含这个头文件 using namespace std; int main() { int i, j, result; for (i = 1; i < 10; i++) // for i 外循环:i 对应行,从 1 到 9 { for (j = 1; j <= i; j++) // for j 内循环:j 对应列,从 1 到 i { result = i * j; // 计算乘积 cout << i << "*" << j << "=" << setw(3) << result; // result 占 3 位 } cout << endl; // 内循环结束后换行 } return 0; }
运行结果(节选):
$ g++ -o table99 table99.cpp $ ./table99 1*1= 1 2*1= 2 2*2= 4 3*1= 3 3*2= 6 3*3= 9 4*1= 4 4*2= 8 4*3= 12 4*4= 16 ... 9*1= 9 9*2= 18 9*3= 27 9*4= 36 9*5= 45 9*6= 54 9*7= 63 9*8= 72 9*9= 81
- 内层循环的语句组是外层循环体中的一部分,称为循环嵌套
- 外循环每执行一次,内循环要执行 i 次,从而在第 i 行输出 i 个式子
setw(3)设置输出宽度:让 result 的值最多占 3 位十进制数,不足 3 位用空格补齐,所以每列对得很齐。教材的 VC 6.0 里不写#include <iomanip>也能过,在 Linux 的 g++ 下必须写上,否则会报setw was not declared- 教材运行结果里那句 “Press any key to continue” 是 VC 自动加上的,Linux 终端下没有,程序结束直接回到命令提示符
【类似练习】仿照例题 4.4,输出一个倒三角的乘法表(第 1 行输出 9 个式子,第 9 行输出 1 个式子)。提示:把内循环改成 for (j = 1; j <= 10 - i; j++)。
4.4 分支结构
为了完成任务 4.1,光有循环结构不行,还要有用来判断条件是否已经满足(有 3 个人说的话是真话)的分支结构:
if (sum == 3) { cout << "The head is: " << (char)(64 + k) << endl; // 输出主谋 head }
这段程序可以读作:“如果 sum 真的为 3,输出谁是主谋。”
- 这里用到了强制字符类型转换
(char):0~127 之间的整数都可以通过(char)转成对应字符,即把64+k的整数值当成 ASCII 码输出 - 如果只写
64 + k,输出的会是 65、66 这样的数字;加上(char)才会输出 A、B 这样的字符
4.4.1 if 语句的一般格式
if (表达式) { 语句块1; } else { 语句块2; }
- 说明:如果 if 表达式中的条件为真,执行语句块 1;否则执行 else 后面的语句块 2(教材图 4.6 的流程图)
- else 以及后面的语句块 2 可以省略,此时“条件不满足”就什么都不做
4.4.2 if 语句实例
【任务 4.4】某大型超市节假日促销,一次性购物满 600 元的顾客所购商品可以打八折。试编一程序判断商品打折情况。
解题思路:用 if 语句判断购物额 num 是否大于 600,大于则输出打折价 num * 0.8,否则输出原价。
【例题 4.5】商品打折(对应教材程序 4_4free.c):
// 程序名:discount.cpp // 主要功能:商品打折 #include <iostream> using namespace std; int main() { double num; // 声明实型变量 num cout << "请输入一次性购物数额:"; cin >> num; // 从键盘输入实数给 num if (num > 600) // 条件满足 cout << "您消费:" << num << "元,可以打八折,只要付:" << num * 0.8 << "元" << endl; else // 条件不满足 cout << "您消费:" << num << "元,不足 600 元,不打折" << endl; return 0; }
运行结果:
$ g++ -o discount discount.cpp $ ./discount 请输入一次性购物数额:700 您消费:700元,可以打八折,只要付:560元
- 教材里用的是
float,这里用了double:Linux 的 g++ 下两者都支持,但 double 精度更高,做金额计算更稳 - 教材文件名是 4_4free.c,C++ 源文件统一用 .cpp 结尾,名字自取,不要带空格
【类似练习】改成“满 200 打九折、满 500 打八折、满 1000 打七折”,用 if…else if…else 实现。
4.5 任务 4.1 的算法分析
前面讲完了程序的循环结构与分支结构,已经具备解决任务 4.1(谁是主谋)的编程基础。本节希望读者能根据题意先写出程序框图(教材图 4.8),再照着框图写程序,这是很容易写出程序的办法。
4.5.1 任务 4.1 的解法 1
思路:以 k 为循环控制变量(k 可理解为被测试的第 k 个人,k 从 1 到 4 一个一个试),循环体由两块组成:第 1 块是顺序结构,含两条赋值语句;第 2 块是分支结构,判断第 k 个人是不是主谋。
【例题 4.6】解法 1(对应教材程序 4_5.cpp):
// 程序名:who_head1.cpp // 主要功能:分析谁是主谋 #include <iostream> using namespace std; int main() { int k = 0, sum = 0; // 变量 k、sum 均为整型,初始化为 0 char head = ' '; // head 为字符型,初始化为空 for (k = 1; k <= 4; k = k + 1) // k 既是循环控制变量,也表示第 k 个人 { head = 64 + k; // 枚举第 k 个人是主谋 sum = (head != 'A') // 将 4 个罪犯所说的话加在一起 + (head == 'C') + (head == 'D') + (head != 'D'); if (sum == 3) // 如果有 3 句话为真,则输出此人 { cout << "The head is: " << (char)(64 + k) << endl; } } return 0; }
运行结果:
$ g++ -o who_head1 who_head1.cpp && ./who_head1 The head is: C
4.5.2 任务 4.1 的解法 2
对解法 1 进一步优化:用数字 1、2、3、4 分别代替罪犯 A、B、C、D(教材表 4.7:原题 → 优化 → 语言描述)。
表 4.7 任务 4.1 的解法 2 算法分析
| 原题 | 优化 | 语言描述 |
|---|---|---|
| A、B、C、D 罪犯 | 1、2、3、4 罪犯 | for(k=1;k<=4;k++) |
| A 说:不是我 | 1 说:不是 1 | if(k!=1) sum=sum+1; |
| B 说:是 C | 2 说:是 3 | if(k==3) sum=sum+1; |
| C 说:是 D | 3 说:是 4 | if(k==4) sum=sum+1; |
| D 说:他胡说 | 4 说:不是 4 | if(k!=4) sum=sum+1; |
【例题 4.7】解法 2(对应教材程序 4_6.cpp):
// 程序名:who_head2.cpp // 主要功能:查出主谋 #include <iostream> using namespace std; int main() { int k = 0, sum = 0; for (k = 1; k <= 4; k = k + 1) // 循环变量 k 从 1 到 4,枚举 k { sum = 0; // 每换一个人都要重新统计,这一步不能少 if (k != 1) sum = sum + 1; // 如 A 的话为真,则 sum 加 1 if (k == 3) sum = sum + 1; // 如 B 的话为真 if (k == 4) sum = sum + 1; // 如 C 的话为真 if (k != 4) sum = sum + 1; // 如 D 的话为真 if (sum == 3) // 若有 3 句话为真,则第 k 人为主谋 { cout << "The head is: " << (char)(64 + k) << endl; } } return 0; }
- 与解法 1 相比,关系表达式的值不再直接相加,而是用 if 一句一句地累加,思路更直白
sum = 0;必须写在循环体内:每换一个被测试者,都要重新统计真话的句数
4.5.3 任务 4.1 的解法 3
解法 2 里 4 个人说的话对应 4 条 if 语句,能不能合并成 1 条?从 4 个条件来看:
- 条件 1:
k != 1满足为 1,不满足为 0 - 条件 2:
k == 3满足为 1,不满足为 0 - 条件 3:
k == 4满足为 1,不满足为 0 - 条件 4:
k != 4满足为 1,不满足为 0
每个条件都有真有假、非 1 即 0,4 个条件加在一起结果等于 3,就可以确定第 k 人是主谋。于是程序可以大大简化。
【例题 4.8】解法 3(对应教材程序 4_7.cpp):
// 程序名:who_head3.cpp // 主要功能:分析谁是主谋 #include <iostream> using namespace std; int main() { int k = 0; for (k = 1; k <= 4; k = k + 1) { if (((k != 1) + (k == 3) + (k == 4) + (k != 4)) == 3) { cout << "This man is: " << (char)(64 + k) << endl; } } return 0; }
运行结果:
$ g++ -o who_head3 who_head3.cpp && ./who_head3 This man is: C
- 同一个问题可以用多种方法实现(解法 1、2、3 结论一致),应尽量选择又对又简的写法
4.6 逻辑问题及其解法
【任务 4.5】黑客制造病毒、破坏互联网是违法的。刑侦人员接到举报,A、B、C 三人都可能有制造某种病毒的嫌疑,经排查分析得出 3 条结论:
- A、B、C 三人至少有两人涉嫌作案
- A 和 C 不是同案犯
- B 和 C 或同时作案,或都与本案无关
请根据这 3 条判断出谁是作案者。要解这道题,首先要研究逻辑运算符与逻辑表达式。
4.6.1 逻辑运算符与逻辑表达式
1. 逻辑与 &&
- 逻辑与的运算符为
&&。教材图 4.9 用开关串联电路说明:两个开关都合上灯才亮,真值表里也只有 A=1、B=1 时 A&&B 才是 1 - 1 表示真、0 表示假,这是逻辑变量的两个取值,非真即假
- 身边的例子:用手机打电话必须同时满足两个条件——手机和手机卡。用 a 表示一台可用的手机、b 表示一张可用的手机卡,就用
a && b表示能打电话(教材表 4.8)
【任务 4.6】输入一个字母,试编一程序判断该字符是否为小写字母。
解题思路:小写字母在 ASCII 码表中是一个范围,码值既要 >= 'a',又要 <= 'z',两个条件缺一不可,所以用逻辑与(&&)包含这两个条件,再用 if…else 做分支判断。
【例题 4.9】判断小写字母(对应教材程序 4_8.cpp):
// 程序名:lower.cpp // 主要功能:判断输入字符是否为小写字母 #include <iostream> using namespace std; int main() { char zf; cout << "请输入一个字符:"; cin >> zf; // 输入一个字符给变量 zf if (zf >= 'a' && zf <= 'z') // 判断是否为小写字母 cout << "您输入的字符是小写字母" << endl; else cout << "您输入的字符不是小写字母" << endl; return 0; }
运行结果:
$ g++ -o lower lower.cpp && ./lower 请输入一个字符:T 您输入的字符不是小写字母
- 不能写成
'a' <= zf <= 'z':这会被理解成('a' <= zf) <= 'z',先得到 0 或 1 再去和 'z' 比较,结果永远为真
2. 逻辑或 ||
- 逻辑或的运算符为
||。教材图 4.10 用开关并联电路说明:两个开关任一个合上灯就亮,真值表里只要 A、B 有一个为 1,A||B 就为 1 - 身边的例子:人们相互联系的方式很多,打电话、发电子邮件、用即时通信软件都可以。Telephone 为 1 表示可以通过电话联系、Email 为 1 表示可以通过电子邮件联系,则
relation = Telephone || Email(教材表 4.9)
【任务 4.7】王老师与同学们约定:3 门单科成绩中任一门超过 85 分,或者总分超过 240 分,就可以获得一份奖品。试编一程序帮助判断。
解题思路:4 个条件——第 1 门 > 85、第 2 门 > 85、第 3 门 > 85、总分 > 240,只要有一个满足就能得奖,它们之间是“或”的关系,用逻辑或(||)连接 4 个条件,再用 if…else 判断。
【例题 4.10】考试分数与奖励(对应教材程序 4_9.cpp):
// 程序名:prize.cpp // 主要功能:判断是否可以获奖 #include <iostream> using namespace std; int main() { int grade1, grade2, grade3, total = 0; cout << "请输入第一门成绩:"; cin >> grade1; cout << "请输入第二门成绩:"; cin >> grade2; cout << "请输入第三门成绩:"; cin >> grade3; total = grade1 + grade2 + grade3; // 计算总分 if ((grade1 > 85) || (grade2 > 85) || (grade3 > 85) || (total > 240)) cout << "可以获得奖品" << endl; else cout << "不可以获得奖品,下次继续努力" << endl; return 0; }
运行结果:
$ g++ -o prize prize.cpp && ./prize 请输入第一门成绩:87 请输入第二门成绩:81 请输入第三门成绩:78 可以获得奖品
- 使用逻辑运算符时,为了让条件关系一目了然,建议给每个关系表达式都加上圆括号
3. 逻辑非 !
- 逻辑非的运算符为
!,只有一个运算对象,作用是把真变假、把假变真 - 例子:两队比赛篮球,A 表示 A 队到场、!A 表示 A 队不到场;两队都到场才赛得成
C = A && B,赛不成D = !C = !A || !B,读作“A 不到场或 B 不到场”
【任务 4.8】老师随机抽查课外作业完成情况,要求学号为 4 的倍数的学生立即把作业交上来检查。试编一程序,输入一个学号,判断该生的作业是否需要立即检查。
解题思路:用求余运算符 % 判断输入的整数能否被 4 整除,能整除时余数为 0;而 if 是“以非零为真”来执行判断的,我们需要的恰好相反,所以用逻辑非 ! 把结果为 0 的变成非零,再用 if…else 判断。
【例题 4.11】判断学号是否需要立即检查(对应教材程序 4_10.cpp):
// 程序名:check_hw.cpp // 主要功能:判断输入的学号是否需要立即检查 #include <iostream> using namespace std; int main() { int num; cout << "请输入一个学号:"; cin >> num; if (!(num % 4)) // 相当于判断 (num % 4) == 0 cout << "该学生必须立即被检查" << endl; else cout << "该学生不需要立即被检查" << endl; return 0; }
运行结果:
$ g++ -o check_hw check_hw.cpp && ./check_hw 请输入一个学号:90 该学生不需要立即被检查
if (!(num % 4))与if (num % 4 == 0)完全等价,写哪一个都可以,后者更直观
4.6.2 逻辑问题的解题思路与编程技巧
已经知道逻辑与、逻辑或、逻辑非的概念及运算符之后,结合任务 4.5 分析逻辑问题的解题思路。解决这个问题要做以下 3 件事。
(1)定义 3 个“作案与否”的变量 A、B、C(未作案为 0,作案为 1),把案情分析的 3 个条件写成逻辑表达式:
cc1 = (A && B) || (A && C) || (B && C); // 第 1 条:A、B、C 至少有两人涉嫌作案 cc2 = !(A && C); // 第 2 条:A 和 C 不可能是同案犯 cc3 = (B && C) || (!B && !C); // 第 3 条:B、C 同时作案,或都与本案无关
- 逻辑与(&&)在这里表示“二人一起作案”,逻辑或(||)在这里表示“或者”。
cc1可读作:当(A 与 B)或(A 与 C)或(B 与 C)为 1 时,cc1 就为 1 - 案情分析要求 3 个条件同时满足,因此
cc1 && cc2 && cc3才是确定谁是罪犯的依据
(2)分析 A、B、C 谁作案与谁不作案共有 8 种情况
| 情况 | A | B | C | 说明 |
|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 都未作案 |
| 2 | 0 | 0 | 1 | C 一人作案 |
| 3 | 0 | 1 | 0 | B 一人作案 |
| 4 | 0 | 1 | 1 | BC 二人作案 |
| 5 | 1 | 0 | 0 | A 一人作案 |
| 6 | 1 | 0 | 1 | AC 二人作案 |
| 7 | 1 | 1 | 0 | AB 二人作案 |
| 8 | 1 | 1 | 1 | ABC 三人作案 |
这就是从 000 到 111 的 3 位二进制数,可以用三重循环生成这 8 种情况:
// 程序名:enumerate3.cpp // 主要功能:用三重循环枚举 A、B、C 的 8 种取值 #include <iostream> using namespace std; int main() { for (int A = 0; A <= 1; A = A + 1) // 枚举 A 从 0 到 1 { for (int B = 0; B <= 1; B = B + 1) // 枚举 B 从 0 到 1 { for (int C = 0; C <= 1; C = C + 1) // 枚举 C 从 0 到 1 { cout << A << B << C << endl; } } } return 0; }
- 这里顺便用上了 4.7.3 节“表达式 1 就地定义循环变量”的技巧:用到什么变量就在哪里定义
(3)把案情条件加到循环体里,筛出满足条件的组合
以上 8 种排列是三个人参与作案的全部可能性,现在要根据案情分析的 3 个条件排除不符合条件的可能性,留下来的即为所求。
// 程序名:hacker.cpp // 主要功能:根据 3 个条件找出作案者 #include <iostream> using namespace std; int main() { int A, B, C; for (A = 0; A <= 1; A = A + 1) { for (B = 0; B <= 1; B = B + 1) { for (C = 0; C <= 1; C = C + 1) { int cc1 = (A && B) || (A && C) || (B && C); int cc2 = !(A && C); int cc3 = (B && C) || (!B && !C); if (cc1 && cc2 && cc3) // 3 个条件都满足 { cout << "A: " << A << endl; cout << "B: " << B << endl; cout << "C: " << C << endl; } } } } return 0; }
运行结果(满足 3 个条件的组合是 A=1、B=1、C=0,即 A 和 B 作案、C 无关):
$ g++ -o hacker hacker.cpp && ./hacker A: 1 B: 1 C: 0
- 建议上机运行之后,再反过来对照案情分析的 3 个条件逐一验证,以加深对逻辑思维方法的认识与理解
- 在 Linux 下调试这类程序很方便:在循环里临时加上
cout打印跟踪信息,观察每一轮 A、B、C 的取值,就能看清程序到底走了哪些路径(教材也建议用这种“加输出显示”的办法研究程序的运行过程)
4.7 知识拓展
4.7.1 if...else 语句的复杂形式——嵌套分支 if 语句
if (表达式1) { 语句块1; } else if (表达式2) { 语句块2; } ... else { 语句块n; }
- 说明:如果表达式 1 为真,执行语句块 1;否则判断表达式 2,为真则执行语句块 2,为假则继续判断下一个 else if;都不成立时执行最后 else 中的语句块 n
- else 要和与它最近的 if 配对。写法上要注意缩进,最好每个分支都用一对大括号括起来,这样“谁和谁配对”看得清清楚楚
【任务 4.9】古时候某国有法律规定:60 岁以上和 18 岁以下的国民可免除赋税;45~59 岁之间的国民免除一半的赋税;19~44 岁之间的国民需要缴纳全部赋税。试编程序,输入国民的年龄,判断是否需要缴纳赋税或缴纳多少。
解题思路(逐步缩小范围,这是嵌套分支的典型技巧):
- 第 1 步先判免税条件
(age <= 18) || (age >= 60)(称条件 1)。做完这一步后,假如不满足免税条件,age 必在 19~59 之间 - 第 2 步再用 if 判是否满足免一半的条件,本来应写
(age >= 45) && (age < 60)(称条件 2);但此时 age 的范围已经缩小为 18 < age < 60,所以条件 2 可以简化为(age >= 45) - 第 2 步做完后,假如不满足免一半的条件,剩下的人群就是缴纳全部赋税的
【例题 4.12】缴纳赋税(对应教材程序 4_12.cpp):
// 程序名:tax.cpp // 主要功能:根据年龄判断缴纳赋税情况 #include <iostream> using namespace std; int main() { int age; cout << "请输入国民的年龄:"; cin >> age; if (age >= 60 || age < 18) // 先判条件 1 cout << "免除全部赋税" << endl; else if (age >= 45) // 再判条件 2(已可简化) cout << "需缴纳一半赋税" << endl; else // 条件 1、2 都不成立 cout << "需缴纳全部赋税" << endl; return 0; }
运行结果:
$ g++ -o tax tax.cpp && ./tax 请输入国民的年龄:58 需缴纳一半赋税
4.7.2 多分支语句 switch 语句
【任务 4.10】春节将近,某电信公司开展充值“礼油”活动:充值 100 元赠送 1 瓶色拉油,充值 200 元赠送 3 瓶,充值 300 元赠送 6 瓶,充值 500 元赠送 12 瓶。根据输入的充值金额计算赠送几瓶色拉油。
解题思路:共有 4 种送油规则,可用多分支结构实现。C++ 中多分支结构除了用嵌套的 if…else 实现外,还可以用 switch 语句,它专门用于解决多分支结构。
【例题 4.13】根据充值金额回赠色拉油(对应教材程序 4_13.cpp):
// 程序名:oil.cpp // 主要功能:根据充值金额回赠色拉油 #include <iostream> using namespace std; int main() { int value = 0, salad_oil = 0; cout << "请输入充值额:"; cin >> value; switch (value) // 多分支 switch 语句 { case 100: salad_oil = 1; break; // value 为 100 时,赠 1 瓶 case 200: salad_oil = 3; break; // value 为 200 时,赠 3 瓶 case 300: salad_oil = 6; break; // value 为 300 时,赠 6 瓶 case 500: salad_oil = 12; break; // value 为 500 时,赠 12 瓶 } cout << "您充值" << value << "元赠送" << salad_oil << "瓶色拉油" << endl; return 0; }
运行结果:
$ g++ -o oil oil.cpp && ./oil 请输入充值额:200 您充值200元赠送3瓶色拉油
switch 语句的一般形式
switch (表达式) { case 常量表达式1: 语句组1; [break;] case 常量表达式2: 语句组2; [break;] case 常量表达式3: 语句组3; [break;] ... case 常量表达式n: 语句组n; [break;] default: 语句组n+1; [break;] }
用方括号括起来的部分可以省略。switch 语句的说明:
- ① switch、case 和 break 都是 C++ 中的关键字,switch 后面用大括号括起来的部分称为 switch 语句体
- ② switch 后面表达式的值只能是整型数据或字符型数据(不能是实型、字符串)
- ③ “常量表达式”由常量和运算符组成,如
3 + 'a';case 与常量表达式之间用空格隔开。每个 case 后面常量表达式的值应互不相同 - ④ 执行过程:先计算 switch 后面表达式的值,当它与某个 case 后面的常量表达式相等时,就从该 case 后面的语句组开始(这是入口)往下执行,直到遇到 break 或 switch 语句体的结束符
};如果没有相等的常量表达式,则执行 default 后面的语句组 - ⑤ 注意 break 在 switch 中的作用:如果 case 后没有 break,程序会从入口一路往下执行到 switch 结束,这时就不能实现分支结构的功能了
【例题 4.14】把上面的程序改写成带 default、能识别非法输入的版本:
switch (value) { case 100: salad_oil = 1; break; case 200: salad_oil = 3; break; case 300: salad_oil = 6; break; case 500: salad_oil = 12; break; default: salad_oil = -1; break; // value 不是 100、200、300、500 时 } // 作为标志将 -1 赋给 salad_oil if (salad_oil != -1) cout << "您充值" << value << "元赠送" << salad_oil << "瓶色拉油" << endl; else cout << "您输入的值有误" << endl;
- 教材还建议读者故意把 4 个 break 全部去掉再运行一次,输入 300 时会一路执行到最后一个 case,输出结果是错的(只留下最后一次赋值,即 12 瓶),运行一次就能真正体会 break 的作用
【任务 4.11】计算函数值。输入整数 x,根据下面的分段函数计算 y 的值:
y = 1 (x < 0) y = 2 (0 <= x < 5) y = 4 (5 <= x < 15) y = 7 (15 <= x < 30) y = 10 (30 <= x)
解题思路:本题区间的间隔是 5 或 5 的倍数,可以把每个区间分别对应一个数字。由于
- “0 ≤ x < 5”与“x/5 == 0”等价(整数除法)
- “5 ≤ x < 15”相当于“x/5 == 1 或 x/5 == 2”
- “15 ≤ x < 30”相当于“x/5 == 3 或 x/5 == 4 或 x/5 == 5”
因此可以把 x/5 作为 switch 后面的表达式。
【例题 4.15】用 switch 求分段函数的值(对应教材程序 4_14.cpp):
// 程序名:piecewise.cpp // 主要功能:求分段函数的值 #include <iostream> using namespace std; int main() { int x = 0, y = 0; cout << "please input x: "; cin >> x; if (x < 0) y = 1; // 当 x<0 时,y 的值是 1 else // 否则,是 x>=0 的情况 switch (x / 5) // 执行多分支语句 { case 0: y = 2; break; // 当 x/5==0 时,y 的值是 2 case 1: case 2: y = 4; break; // 当 x/5==1 或 2 时,y 的值是 4 case 3: case 4: case 5: y = 7; break; // 当 x/5==3、4 或 5 时,y 的值是 7 default: y = 10; break; // 当 x>=30 时,y 的值是 10 } cout << "x=" << x << "," << "y=" << y << endl; return 0; }
运行结果:
$ g++ -o piecewise piecewise.cpp && ./piecewise please input x: 25 x=25,y=7
- case 后面可以没有语句(如
case 1:、case 2:连写),这时会执行其下面的语句。例如 x=7 时 x/5 的值为 1,执行 case 1 后面的语句,由于其后面没有语句,就继续执行 case 2 后面的y = 4; break;,y 被赋值为 4 后遇到 break 退出 switch - 同样的问题也可以改用 if…else if…else 实现(对应教材程序 4_15.cpp):
if (x < 0) y = 1; // 这时 x<0,y 的值为 1 else if (x < 5) y = 2; // 不用再判断 x>=0,这时 x<5,y 的值为 2 else if (x < 15) y = 4; // 不用再判断 x>=5,这时 x<15,y 的值为 4 else if (x < 30) y = 7; // 不用再判断 x>=15,这时 x<30,y 的值为 7 else y = 10; // 这时已是 x>=30,y 的值为 10
- 由以上例子可以看出:对同一个问题可以用多种方法实现
4.7.3 for 语句的使用技巧
for 语句的格式相当灵活,但建议初学者尽量按部就班地使用 for 语句,把三个表达式都写全。下面以求 1~100 之和为例,讲讲 for 语句的几种特殊用法。
(1)表达式 1 的特殊写法(就地定义循环变量)
这种写法在工程中很常见:在哪里用到什么类型的变量,就立即在相应处加以定义。建议在熟练使用 for 语句格式之后再用。
int sum = 0; for (int i = 1; i <= 100; i = i + 1) // i 在 for 里定义,只在循环中有效 { sum = sum + i; } cout << "自然数 1~100 之和为:" << sum << endl;
(2)去掉表达式 2,即不判断循环条件
此时循环条件始终为真,应在循环体内设法结束循环,否则将成为死循环,运行后终端一直刷屏(按 Ctrl+C 可以强制终止)。
int i = 0, sum = 0; for (i = 1; ; i = i + 1) // for 循环 { if (i > 100) break; // 当 i 大于 100 时,强制跳出 for 循环 sum = sum + i; // 累加求和 } cout << "自然数 1~100 之和为:" << sum << endl;
- 分析题:把
if (i > 100) break;加在sum = sum + i;之后正确吗?答:不正确,这样会把 101 也加进 sum,结果是 5151
(3)去掉表达式 3,即省去修改循环变量的值
这时应在循环体内添加修改循环变量的语句,即 i = i + 1;。
int i = 0, sum = 0; for (i = 1; i <= 100; ) // for 循环(没有表达式 3) { sum = sum + i; // 累加求和 i = i + 1; // 循环控制变量加 1,这一句不能少 } cout << "自然数 1~100 之和为:" << sum << endl;
- 在终端里,“运行前一定要保存,否则内容会丢失”这条提醒同样适用:改完源码忘了保存就编译,编译的还是旧程序
4.7.4 混合表达式
- 在混合表达式中,运算符的操作数属于不同的数据类型,运算时通常会将它们转换为同一类型。操作数的数据类型转换成较高级别的类型,称为类型升级
- 数据类型由低到高的顺序:
char < int < long < float < double - 有两个操作数时,计算表达式时的自动类型转换规则:
- ① char 和 short 转换成 int,float 转换成 double
- ② 如果一个操作数是 double 型,则另一个也转换成 double 型,结果也是 double 型
- ③ 如果一个操作数是 long 型,则另一个也转换成 long 型,结果也是 long 型
- ④ 如果一个操作数是 unsigned 型,则另一个也转换成 unsigned 型,结果也是 unsigned 型
- ⑤ 如果余下的所有操作数是 int 型,结果是 int 型
- 还有一条规则没有在上面讨论:当一个操作数是 long 型、另一个是 unsigned 型时,unsigned 型的值不能用 long 型表示,这时两个操作数都转换成 unsigned long 型
- 一旦应用了这些转换规则,每对操作数都将会转成相同的类型,操作的结果与操作数的类型相同
char ch; int i; float f; double d; result = (ch / i) + (f * d) - (f + 1);
- 转换过程:字符 ch 先转换成 int 型,float 型的 f 转换成 double 型;ch/i 的结果再转换成 double,因为 f*d 是 double 型;最终结果是 double 型,因为此时两个操作数都是 double 型
- 如果表达式包含实数值,通常的做法是把所有的整型常量都转换成 float 型,否则一些表达式可能会丢失其真实值
int x = 10, y = 100, z; z = x / y; // 整数除法:z 被赋值为 0,不是 0.1 cout << "z=" << z << endl;
- Linux 提示:在 64 位 Linux 下
long是 8 字节(教材里的 VC 6.0 中是 4 字节),int仍是 4 字节。想确认自己机器上的实际情况,写一句cout << sizeof(int) << " " << sizeof(long) << endl;跑一下就知道
4.7.5 强制类型转换
- 强制类型转换运算符的形式为带有圆括号的类型名
(类型名),如(int)、(double)、(char) - 用“强制类型转换运算符”可以将其后的一个表达式的值,强制转换成圆括号中指明的类型。例如:
(int) 17.487; // 结果是 17(截断,不是四舍五入) (double) (5 * 4 / 8); // 先算括号里的整数除法得 2,再转成 double,结果是 2.0
- 说明:转换是在括号内的整个表达式计算完成之后才执行的,所以
(double)(5*4/8)得到的是 2.0,而不是 2.5 - 想让两个整数相除得到小数,要先把其中一个操作数转成实型:
int i = 1, j = 3; float x; x = (float) i / (float) j; // 结果是 0.333333 // 若写成 x = i / j; 则两个整数相除,结果是 0
4.7.6 强制跳转语句 break 和 continue
在循环结构的程序中往往要用到两个十分重要的语句:break 和 continue。
【任务 4.12】编写程序,读入 6 个正整数并显示之,当读入的数据为负数时,程序立即结束。
解题思路:① 用 for 循环,从键盘输入数据;② 当输入的数据小于 0 时程序结束;③ 在循环中遇到 break 语句时,立即结束循环,程序控制权传递给循环后的语句。
【例题 4.16】break 版:
// 程序名:brk.cpp // 主要功能:读入 6 个正整数并显示,遇到负数立即结束 #include <iostream> using namespace std; int main() { int i, n; for (i = 1; i <= 6; i++) { cout << "请输入一个整数:"; cin >> n; if (n < 0) break; // 遇到负数,立刻退出循环 cout << "n =" << n << endl; } cout << "程序结束" << endl; return 0; }
【例题 4.17】continue 版(只把 break 换成 continue):
// 程序名:cont.cpp // 主要功能:读入 6 个正整数并显示,遇到负数跳过本次输出 #include <iostream> using namespace std; int main() { int i, n; for (i = 1; i <= 6; i++) { cout << "请输入一个数:"; cin >> n; if (n < 0) continue; // 跳过其后语句,直接进入下一轮循环 cout << "n =" << n << endl; } cout << "程序结束" << endl; return 0; }
- 比较:使用 break 时,读入负数程序立即结束;使用 continue 时,读入负数程序不结束,只是不显示这个数,而是等待输入下一个数据
- break:无条件退出这一层循环。若有多重循环,break 属于哪一层就跳出哪一层,不是跳出全部循环
- continue:不再执行其后的语句,直接跳到前面让循环控制变量增值(或减值)再执行循环体
- 在 Linux 终端里,break/continue 的效果看得很清楚——程序会一直等你敲键盘,按 Ctrl+C 可以随时中止
4.8 思考与实训
【实训 4.1】一球从 200 米高度自由落下,每次落地后反弹回原高度的一半再落下,求它在第 5 次落地时共经过多少米?第 5 次反弹多高?
编程思想:设 s 为球在空中走过的距离、h 为球每次反弹的高度。第一次球落地高度为 200 米,反弹为原高度的一半即 100 米,在离地面 100 米时球总共走过 200+100=300 米;第二次球反弹 50 米,球共走过 200+100+100+50=450 米……这是一个往复运动的过程,编程时要用到循环结构。要求的是第五次落地时球经过的距离,循环次数是具体的,因此可选择 for 循环。
参考程序(题目要求补全的内容):
// 程序名:ball.cpp // 主要功能:求小球第 5 次落地经过的距离和第 5 次反弹的高度 #include <iostream> using namespace std; int main() { float sn = 200.0, hn = sn / 2; // sn 累计经过的距离,hn 反弹高度 for (int n = 2; n <= 5; n++) { sn = sn + hn * 2; // 弹起 hn 再落下 hn,共 2 倍反弹高度 hn = hn / 2; // 下一次反弹的高度减半 } cout << "the total of road is " << sn << endl; cout << "the tenth is " << hn << " meter" << endl; return 0; }
运行结果:
$ g++ -o ball ball.cpp && ./ball the total of road is 575 the tenth is 6.25 meter
【实训 4.2】教材表 4.10 给出了噪音级别和人对噪音的感觉之间的关系,请编出程序,输入噪音分贝数,输出人对噪音的感觉。
表 4.10 声音强度对人的影响
| 噪音(分贝) | 感觉 | 噪音(分贝) | 感觉 |
|---|---|---|---|
| 低于 50 | 安静 | 91~110 | 严重的干扰 |
| 51~70 | 轻微的干扰 | 高于 111 | 有害的噪声 |
| 71~90 | 干扰 |
提示:用 if…else if…else 按区间从低到高逐个判断即可。
【实训 4.3】求输入正整数的阶乘。运行结果要求:输入 6,输出“6 的阶乘 = 720”。
编程思想:6! = 6×5×4×3×2×1,通过 for 语句实现连续多个值相乘。提示:参考任务 4.2 求自然数 1~100 之和,把循环体内的相加改为相乘,注意连乘的初值要取 1。
【实训 4.4】输出 9+9 口诀加法表。提示:根据任务 4.3 输出 9×9 口诀表的结构模式,把 for 循环体内的相乘改为相加。
【实训 4.5】上机完成以下内容:有以下程序段
if ((a > 2) && (b == 1)) x = x / a; if ((a == 3) || (x > 1)) x = x + 1;
要求增加一些输入语句和输出语句,使上述程序能在不同的 a、b 和 x 值下运行,并且能观察程序流程经过(覆盖)了哪些语句、哪些分支及哪些路径。请分别用下列各组数据运行并记下操作流程:
- ① a=1, b=0, x=1
- ② a=1, b=1, x=2
- ③ a=3, b=1, x=1
- ④ a=2, b=1, x=4
- ⑤ a=2, b=1, x=1
- ⑥ a=1, b=0, x=2
- ⑦ a=4, b=1, x=1
- ⑧ a=3, b=0, x=2
【实训 4.6】用键盘输入 3 条线段的长度,请写一个程序判断这 3 条线段所组成的三角形属于哪种类型(不等边三角形、等腰三角形、等边三角形),或者构不成三角形。
提示:先用“任意两边之和大于第三边”判断能否构成三角形,再依次判断等边、等腰,都不满足就是不等边三角形。
4.9 小结
本章的内容十分丰富,且十分重要,重点是从解题思路出发引出需要掌握的一些程序结构和语句。
- ① 解题的重要一步是“翻译”:要把人的想法表示成机器能够实现的表达式、数学公式或操作步骤。首先遇到的问题可能是“是”还是“否”、“等于”还是“不等于”、“大于”还是“小于”,这些要描述成关系表达式,就要用关系运算符,因此灵活地使用关系运算符就显得十分重要
- ② 逻辑运算不可缺少:用计算机解题时很多时候涉及逻辑运算,因此掌握逻辑运算符和构造逻辑表达式也是十分重要的
- ③ 枚举法 + 循环结构:用计算机解题往往需要从许多种可能性中去寻找其中的一种或几种,最容易想到、也最容易做到的就是“枚举法”。要用枚举法就会遇到大量重复计算的问题,自然要用到程序的循环结构,因此掌握循环结构的程序设计是一个非常重要的基本功
- ④ 分支是计算思维的重要方式:掌握且灵活运用它并不十分困难
4.10 知识巩固
【试题 1】以下程序输出的结果是。
int main() { int a = 5, b = 4, c = 3, d; d = (a > b > c); cout << d; return 0; }
提示:先算 a > b 得 1,再算 1 > c 得 0,所以 d 为 0。
【试题 2】若变量 c 为 char 类型,能正确判断出 c 为小写字母的表达式是。
- A.
'a' <= c <= 'z' - B.
(c >= 'a') || (c <= 'z') - C.
('a' <= c) and ('z' >= c) - D.
(c >= 'a') && (c <= 'z')
答案:D。A 会被理解成 ('a' <= c) <= 'z',恒为真;B 用的是“或”,范围被放得太大。
【试题 3】以下程序运行后的输出结果是。
int main() { int a, b, c; a = 10; b = 20; c = (a % b < 1) || (a / b > 1); cout << a << b << c << endl; return 0; }
提示:a % b 为 10,10 < 1 为假(0);a / b 为 0(整数除法),0 > 1 为假(0);两个都是假,c 为 0。输出 10200。
【试题 4】以下程序运行后的输出结果是。
int main() { int a = 1, b = 3, c = 5; if (c == a + b) cout << "yes "; else cout << "no"; return 0; }
提示:a+b 为 4,与 c(5)不相等,条件为假,输出 no。
【试题 5】有以下程序:
int main() { int k = 5, n = 0; for (k = 5; k > 0; k--) { switch (k) { default: break; case 1: n += k; case 2: case 3: n += k; } } cout << n; return 0; }
程序运行后的输出结果是。
- A. 0 B. 4 C. 6 D. 7
提示:这道题难度较大。因为 case 后面没有 break,程序会“跌落”往下执行。逐轮推演:
- k=5:没有匹配的 case,执行 default(什么都不做)
- k=4:同上
- k=3:匹配 case 3,
n += k得 n=3 - k=2:匹配 case 2,它后面没有语句,继续执行 case 3 的
n += k,得 n=3+2=5 - k=1:匹配 case 1,
n += k得 n=6,接着继续执行 case 2、case 3 的n += k,得 n=6+1=7
答案是 D(7)。教材建议在程序里临时加上几条 cout 跟踪语句,把每轮 k、n 的值和走过的 case 打印出来,就能把执行过程看得一目了然。
【试题 6】有如下程序段,其中 s、a、b、c 都已经定义为整型变量,且 a、c 均已赋值(c>0):
s = a; for (b = 1; b <= c; b++) s = s + 1;
与上面语句等价的赋值语句是。
- A.
s = a + bB.s = a + cC.s = s + cD.s = b + c
答案:B。循环体执行 c 次,每次给 s 加 1,效果就是 s 加上 c。
【试题 7】以下程序的循环体的执行次数是。
int main() { int i, j; for (i = 0, j = 1; i < j + 1; i += 2, j--) cout << i; return 0; }
手工推演:第一次判断 0 < 1+1 为真,执行循环体,然后 i += 2 得 2、j-- 得 0;第二次判断 2 < 0+1 为假,循环结束。所以循环体只执行了 1 次(输出 0)。这类题一定要动手推演或上机运行,不要凭感觉。
【试题 8】有以下程序:
int main() { int i, sum; for (i = 1; i <= 3; sum++) sum += 1; cout << sum; return 0; }
该程序执行后的结果是。
- A. 6 B. 3 C. 死循环 D. 0
答案:C。for 的表达式 3 修改的是 sum 而不是循环控制变量 i,i 始终为 1,判断条件永远成立,循环不会结束;顺带提醒,这里 sum 也没有初始化,其值是随机的。