{{ :程序设计基础_13521005.pdf |}}
> 本页对应教材第 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
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
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
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
#include // 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 ` 也能过,在 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 + b` B. `s = a + c` C. `s = s + c` D. `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 也没有初始化,其值是随机的。
```mdk
# 第4章 逻辑思维与编程思路
## 4.1 关系运算和关系表达式
### 关系运算符
- >= > == <= < !=
- 例题 4.1 验证关系运算符
### 一般格式
- <变量1> 关系运算符 <变量2>
- 值只有真(1)或假(0)
```