企业官网建设流程全解析

简介：《C语言程序设计第四版》何钦铭课后习题及答案PDF，面向高校C语言课程学习者、备考学生和自学者，用于对照教材章节完成课后练习、核对答案并理解易错点。压缩包共1个PDF文件，大小约2.67MB，内容按教材章节组织，包含选择题、程序改错、代码填空、流程图分析与编程题解答，并附标识符、保留字、变量声明、流程控制、函数、数组和字符串等基础知识的解析。读者可据此查看完整答案、代码示例与解题思路，快速定位第一章至后续章节的练习要点，适合课堂同步学习、期末复习和查漏补缺。已有12328人学习下载，可作为教材配套的练习参考答案使用。

1. 别急着抄答案：这份课后习题解析真正能练的是什么

这份 C 语言程序设计（第四版）课后习题与答案解析，翻开就是满屏的“答：”和“解析：”，很像能直接抄的那种教辅。按章节把第一章四道题、第二章的选择填空和编程题全跑一遍才会发现，它更像一份带参考答案的回归训练场：每道题只盯住一个语法点，标识符命名、整除取余、scanf格式串对齐、运算符优先级、if-else花括号配对、for循环边界，一个点一道题，抄错一行编译不过，跑起来就露馅。刚学完语法但写不出完整程序的新手，能照着它把每个知识点跑通；隔了几年要重新捡 C 做嵌入式或者刷题的从业者，可以拿它当查漏清单。下面按章节顺序拆开，每道题都落到能编译、能出结果的代码上。

2. 标识符与关键字的判定规则：从 5 个用例到一份可编译的验证清单

第一章第 1 题只给了 5 个用例，问哪些合法哪些不合法。答案本身没什么好背的，真正有用的是它背后那三条判定规则，以及怎么用编译器把判断结果验证一遍——毕竟标识符这块是最容易被自己骗过去的地方，看着顺眼就以为对了。

2.1 合法标识符的三条硬规则与两个易错边界

先把规则摊开：标识符只能由字母、数字、下划线组成；首字符必须是字母或下划线，不能是数字；不能和关键字重名，且大小写敏感，Total和total是两个完全不同的名字。原题那 5 个用例套进去就是一张表：

光看表没用，把合法的四个真写成变量，编译一遍才算数：

/* ident_ok.c —— 只放合法标识符，验证它们确实能定义 */ #include <stdio.h> int total = 0; /* 全小写字母 */ int _debug = 1; /* 下划线开头 */ int Counter1 = 2; /* 字母开头，数字在中间 */ int begin_ = 3; /* 下划线结尾，合法 */ int main(void) { printf("%d %d %d %d\n", total, _debug, Counter1, begin_); return 0; }

编译命令带上双告警开关，习惯从第一天就养成：

gcc -std=c99 -Wall -Wextra -o ident_ok ident_ok.c && ./ident_ok

-std=c99是给后面几章的循环内定义变量留的口子，-Wall -Wextra是让编译器把所有可疑写法都喊出来。输出0 1 2 3，说明这四个名字都通过了词法分析和符号表登记。接着把不合法的那条单独拎出来编译：

int Large&Tall = 0; /* 故意写错：& 是取地址运算符，不是标识符合法字符 */

编译器会在&这个 token 处停下，报形如expected '=', ',', ';' ...的错误，而不是提示“非法标识符”——这是个很典型的误解点，工具报的是它解析不下去的位置，不是你的错误本质。所以看到这类错误，第一反应应该是往左看一个 token，而不是盯着报错行本身。

再补两个原题没写、但工程上必须知道的边界。一是数字开头，int 1st;会直接报expected identifier，判断依据是词法阶段就不认；二是保留前缀，C 标准里以双下划线开头、或者下划线加一个大写字母开头的标识符，是留给编译器和标准库的，你写了未必报错，但在换编译器或者升级版本时可能突然撞名，这类玄学问题排查起来很费时间。我一般只允许单个下划线加小写字母开头的自定义名字，_debug这种写法在自己的代码里保留，风格上统一。

2.2 32 个关键字：分类记比顺序背有用

原题附了一份完整的关键字清单，从auto一路列到while。数一下是 32 个，对应的是 C89 的关键字集合。按功能分组记，比按字母顺序背效率高得多：

• 类型相关：charshortintlongfloatdoublevoidsignedunsigned，加上构造类型的structunionenumtypedef
• 存储类：autoexternregisterstatic
• 流程控制：ifelseswitchcasedefaultforwhiledobreakcontinuegotoreturn
• 其他：constsizeofvolatile

需要说明的是，C99 之后又增加了inline、restrict、_Bool、_Complex、_Imaginary这几个，所以你在新版编译器里看到 32 这个数字对不上，不是清单错了，是标准版本不同。这一点在跨平台编译老代码时经常造成误判，特别是inline——C89 里它完全是个合法标识符，有人就拿它当函数名用过，迁到 C99 就炸了。

如果对某个词到底是不是关键字拿不准，写个循环批量验证比翻书快：

# 把一组待测词逐个写成变量声明，编译不过的就是关键字 for kw in auto break case char const continue default do double else; do echo "int $kw = 0; int main(void){return 0;}" > /tmp/kwtest.c if gcc -std=c89 -fsyntax-only /tmp/kwtest.c 2>/dev/null; then echo "$kw 可以用作变量名" else echo "$kw 是关键字" fi done

-fsyntax-only只做语法检查不产出目标文件，跑起来很快，适合塞进脚本里批量测。这个循环把词表换成完整的 32 个，就是一份可复现的关键字清单验证，比抄答案可靠。注意sizeof这种运算符也在关键字表里，int sizeof = 0;一样会被拒绝，别被“运算符不算关键字”的直觉带偏。

2.3 第一章四道题的复现顺序：先跑通，再回头对流程图

第一章第 2 题要求把流程图 1.2 改写成求 1 到 100 中能被 6 整除的所有整数之和，第 3 题要求写成程序并验证，第 4 题是素数判别的流程图。合理的复现顺序是先跑第 3 题的代码拿到确定结果，再拿这个结果去核对第 2 题的流程图，最后把第 4 题的流程图落成代码——流程图形是静态的，代码跑起来才有反馈，顺序反了容易在纸上绕圈。

求和代码原样是这样：

#include <stdio.h> int main(void) { int i, sum = 0; for (i = 1; i <= 100; i++) /* 边界：1 到 100，含 100 */ if (i % 6 == 0) /* 判据：余数为 0 即整除 */ sum = sum + i; printf("sum=%d\n", sum); return 0; }

三个参数值得说清楚：i的初值 1 和终止条件i <= 100共同决定了区间是闭区间，写成i < 101等价但可读性差一点；i % 6 == 0是唯一的筛选条件，注意是==不是=；sum用int完全够，1 到 100 全加也只有 5050，不会溢出。运行结果是sum=816，手算核对一遍：6 的倍数从 6 到 96 共 16 项，提取公因子得 6×(1+2+…+16)=6×136=816，对得上。

素数那道题，教材给的思路是从 2 一直试除到 n-1，落到代码是：

#include <stdio.h> int main(void) { int n, i; int is_prime = 1; /* 先假定是素数，找到因子再推翻 */ scanf("%d", &n); if (n <= 1) is_prime = 0; /* 教材假设 n>1，这里补上边界 */ for (i = 2; i < n; i++) { if (n % i == 0) { is_prime = 0; break; /* 找到一个因子就够了，提前退出 */ } } printf("%d is %s\n", n, is_prime ? "prime" : "not prime"); return 0; }

is_prime这个标志变量是整段逻辑的核心，它把“循环里发现因子”和“循环结束后统一输出”两件事解耦，避免在循环体内直接printf造成多次输出。break是必要的优化，没有它程序结果仍然正确，但会白跑完剩下的所有试除。n <= 1的判断是原答案没写的，教材默认输入合法，实际跑的时候总有人输 1 或者 0，加上这一行能省掉一次困惑。

用几组数据过一遍，看看分支覆盖是否完整：

这张表其实就是第二章那道“至少设计 3 组测试用例”的答案雏形，思路是一样的：每个分支至少一组，边界单独一组。

3. 运算符与输入输出：整除取余、scanf 格式串、优先级三条主线

第二章的选择题看着零散，其实就围着三件事转：整数运算的截断规则、scanf/printf的格式串对齐、运算符优先级。这三块是 C 语言里最容易被“看起来对”糊弄过去的地方，编译能过、程序能跑，结果就是不对。

3.1 整除与取余：为什么 123/100 得到的是 1

原题四个选项，123/100、901%10、76%3的值都是 1，625%5是 0。规则只有一条：两个int相除，结果还是int，小数部分直接截掉，不是四舍五入。取余%拿的是除法剩下的那部分，901除以10商 90 余 1，所以901%10是 1；625除以5整除，余数为 0。

写段代码把这几个值和浮点除法放一起对比，比看解析直观：

#include <stdio.h> int main(void) { int a = 123, b = 100; printf("%d %d\n", a / b, a % b); /* 1 23 */ printf("%.2f\n", (double)a / b); /* 1.23，先转 double 再除 */ printf("%d %d\n", -123 / 100, -123 % 100); /* -1 -23 */ return 0; }

关键在第二行：(double)a / b先做类型转换再做除法，两个操作数里只要有一个是浮点型，另一个会被自动提升，结果才是 1.23。如果写成(double)(a / b)，括号强制先算整数除法，转完还是 1.00，这是血泪经验级别的高频错误。

第三行涉及负数。从 C99 起，整数除法的商向零取整，余数的符号跟被除数一致，所以-123/100是 -1 而不是 -2，-123%100是 -23。C89 时代这一条是“实现定义”的，不同编译器可能给出不同结果，跨平台代码里对负数取余要格外小心，能不用就不用。

回到第二章那道填空题：1/k的结果类型是整型，1.0/k的结果类型是实型。原因就是上面这条——1.0是double，k被提升成double再除。这个知识点在后面编程题里反复出现，四个整数求均值那段如果写成sum / 4，输出永远是整数，.1f也救不回来。

3.2 scanf 与 printf 的格式串对齐：输入 3 和 1.25 只有一个选项对

原题四个选项里只有 A 是对的，但每个错误选项错的地方不一样，值得逐个拆。给定x是double、n是int，输入3 1.25：

• Ascanf("%d%lf", &n, &x)：%d配int*，%lf配double*，顺序也对，正确。
• Bscanf("%lf%d", &x, &n)：类型匹配没错，但顺序反了，先读的%lf会把 3 读成 3.0 塞给x，第二个才读 1.25 给n，而%d遇到小数点就停，n得到 1。程序不崩，值全错，这类 bug 最难查。
• Cscanf("%lf%d", &n, &x)：%lf要求double*，传进去的却是int*的地址，属于未定义行为，运气好是乱值，运气不好直接崩。
• Dscanf("%d, %lf", &n, &x)：格式串里多了个逗号。scanf里的普通字符必须和输入逐字匹配，输入里没有逗号，第二个转换就失败了，x保持原值。

实际写的时候，返回值一定要接：

#include <stdio.h> int main(void) { int n; double x; int r = scanf("%d%lf", &n, &x); /* 返回成功转换的项数 */ if (r != 2) { printf("input failed, r=%d\n", r); return 1; } printf("n=%d, x=%.2f\n", n, x); return 0; }

scanf的返回值是成功赋值的变量个数，遇到第一个转换失败就停下并返回已成功的数量。输入3 abc会得到r=1，输入abc得到r=0，都不是 2，程序直接走错误分支，比在后面的逻辑里对着一个随机值调试强太多。

printf那边的坑是同一条的镜像：%d的个数必须和后面整型参数一一对应，少了多了都是未定义行为。还有个小细节容易混——printf里%f和%lf从 C99 起是等价的，都按double输出；但scanf里两者不等价，%f读的是float，%lf读的是double。这个不对称性几乎是每个新手都会踩一次的坑。

3.3 运算符优先级与 if-else 配对：两条能靠编译器兜底的规则

优先级那道题选=。顺序是算术运算符高于关系运算符，关系运算符高于赋值运算符。*和%是算术，==是关系，=是赋值，所以赋值垫底。这条规则的意义在于让z = x > y能按预期解析成z = (x > y)，而不是(z = x) > y。

#include <stdio.h> int main(void) { int x = 3, y = 4, z; z = x > y; /* 先算关系，再赋值，z = 0 */ printf("z=%d\n", z); z = x = y; /* 赋值右结合：先 x = y，再 z = x，都是 4 */ printf("x=%d z=%d\n", x, z); printf("%d\n", 2 + 3 * 4 > 10); /* 14 > 10，得 1 */ return 0; }

第二行是赋值运算符右结合的例子，链式赋值能成立就靠这条。第三行把算术、关系两级放在一起，先算3*4，再算2+12，最后比较，得到 1。

if-else那道填空题选} else {，理由就是花括号必须成对。这里延伸出一个真正的经典陷阱——悬挂else：

if (x > 0) if (x > 10) printf("big\n"); else printf("small\n"); /* 这个 else 绑给内层的 if，不是外层的 */

else永远绑定到最近的那个未配对if，外层x > 0为假时，这段代码什么都不输出，看起来像是漏了分支。解决办法是强制给每层都写花括号，即便只有一行。我现在写if基本不写单行体，clang-format一格式化就能看出层级，省了很多事后排查。

最后是测试用例设计那道题。给两个数取较大值，三个分支是a > b、a == b、a < b，所以 D 选项的(3,4) → 4、(5,5) → 5、(4,3) → 4才完整。C 选项覆盖的是大、等、负三种情况，漏掉了a < b这个正向分支，一旦把if里的比较写反，它测不出来。设计用例的原则不是“多”，是“每个分支至少一次，边界单独一次”。

4. 控制结构实战：能被 6 整除求和、素数判别、级数求和

第二章后半段的编程题把前面所有知识点串起来用了。这部分的答案代码本身质量可以，但直接抄会漏掉几个工程上必须处理的地方：循环边界的选择、整数除法的隐式类型、分支顺序对结果的影响、输出格式的宽度控制。下面按题拆。

4.1 素数判别：循环边界从 n-1 收到 sqrt(n) 的实测对比

教材版本的边界是i < n，逻辑正确但对大数很吃亏。常见的收法有两种：试到n/2，或者试到sqrt(n)。第二种试除次数最少，边界写成i * i <= n可以完全避开浮点误差，比调用sqrt()稳。

#include <stdio.h> /* 版本 A：教材写法，i 从 2 走到 n-1 */ int is_prime_a(int n) { int i; if (n <= 1) return 0; for (i = 2; i < n; i++) if (n % i == 0) return 0; return 1; } /* 版本 B：i*i <= n，先排掉偶数再只试奇数 */ int is_prime_b(int n) { int i; if (n <= 1) return 0; if (n == 2) return 1; if (n % 2 == 0) return 0; /* 大于 2 的偶数直接排除 */ for (i = 3; i * i <= n; i += 2) /* 步长 2，跳过所有偶数 */ if (n % i == 0) return 0; return 1; }

版本 B 里i * i <= n是核心，它等价于i <= sqrt(n)，但不需要math.h，也不会有sqrt返回值是double带来的边界抖动。i += 2步长省掉一半试除，前提是前面已经把偶数和 2 单独处理干净了，顺序不能反。

两个版本用同一批数字跑一遍试除次数，差距很直观：

版本 A 的“次数”是按最坏情况算的，命中因子会提前退出。这张表想说明的不是性能优化，而是边界选错会让人误以为程序慢，转头去怀疑编译器——这类误判在新手阶段特别常见。另外is_prime_b这种带提前返回的写法，要求每个分支都明确return，漏一条路径编译器未必报警，-Wall配-Wreturn-type能兜住大部分。

4.2 级数求和：把 ∑(i² + 1/i) 翻译成累加循环

题目是输入两个正整数m和n，求从m到n的 ∑(i² + 1/i)，结果保留 6 位小数。整个式子拆开就两个累加项，难点全在类型上：

#include <stdio.h> int main(void) { int m, n, i; double sum = 0.0; printf("input m,n(0<m<=n):"); if (scanf("%d%d", &m, &n) != 2) { printf("bad input\n"); return 1; } if (m <= 0 || n < m) { /* 题目约束 0<m<=n，非法直接退出 */ printf("invalid range\n"); return 1; } for (i = m; i <= n; i++) sum += (double)i * i + 1.0 / i; /* 两处关键：i*i 先转 double，1.0/i 才是浮点除 */ printf("%.6f\n", sum); return 0; }

第一个关键点是(double)i * i。i是int，i * i在int范围内算，i到几万的时候平方早就溢出了，之后再加到double上是拿错误的值去加。先转double再乘，结果就一直在浮点范围里。

第二个关键点是1.0 / i。写成1 / i的话，除了i=1能得 1，其余全是 0，整道题的答案直接小一大截，而程序不报任何错。这是这份答案里最容易翻车的一处，翻车原因是它静默失败。

验证一下m=1, n=3：(1+1) + (4+0.5) + (9+0.333333) = 15.833333，跑出来对得上就说明累加逻辑没问题。输出格式%.6f对应“保留 6 位小数”，double配%f是正确的，不需要%lf。

4.3 阶梯电价：分支顺序决定边界归属

阶梯电价这题的分段是：50 度以内（含 50）每度 0.53 元，超过 50 的部分每度加 0.05 元。代码本身不长，但分支顺序写错会把边界算重：

#include <stdio.h> int main(void) { double x, y; printf("input x:"); if (scanf("%lf", &x) != 1) return 1; if (x < 0) { printf("Invalid Value!\n"); /* 负数视为非法输入 */ } else if (x <= 50) { y = 0.53 * x; printf("%.2f\n", y); } else { y = 0.53 * 50 + (x - 50) * 0.58; /* 超出部分单价 0.53+0.05 */ printf("%.2f\n", y); } return 0; }

三个分支的顺序不能调：先判x < 0，否则负数会落进x <= 50被算成负电费；x <= 50用了小于等于，保证 50 这个点归到第一档；最后的else覆盖x > 50，不需要再写条件。

用几个点验一下边界归属：

还有个小细节原答案里值得提一句：非法输入的提示串里把Invalid拼成了Invaild。自己练无所谓，如果这题要提交到自动判题系统，输出串是逐字符比对的，拼错直接判错，而你自己本地肉眼是看不出来的。写这类题目时我一般先把提示串复制到常量里，全局只用一次。

4.4 四个整数求均值：平均值的类型与显示位宽

题目要求输入 4 个整数，输出和与平均值，平均值精确到小数点后 1 位。这段代码的坑全在一行里：

#include <stdio.h> int main(void) { int a, b, c, d, sum; double average; printf("input a,b,c,d:"); if (scanf("%d%d%d%d", &a, &b, &c, &d) != 4) { printf("bad input\n"); return 1; } sum = a + b + c + d; /* 和一定是整数，用 int */ average = sum / 4.0; /* 除以 4.0 才是浮点除，除 4 会截断 */ printf("average=%.1f\n", average); return 0; }

sum / 4是整数除法，1+2+3+4=10会得到 2 而不是 2.5，再赋值给double也来不及了。sum / 4.0里4.0是double，sum被自动提升，结果才是 2.5。这个点跟 3.1 节是同一条规则，只是换了场景，所以真正记住规则比记住每道题的答案有用。

%.1f控制显示一位小数，注意这里只是影响printf的显示，average本身仍然是完整的双精度值，后面如果还要参与计算，用的是全精度的那个，不是显示出来的两位。这个区别在后续做累加的时候会咬人。

5. 避坑与排查：这份答案里最容易照抄出错的 5 个地方

答案给的是正确代码，但把“正确”变成“我的正确”的过程中，最容易出问题的从来不是算法思路，是一些编译器明明能提醒、却总被忽略的细节。下面五条都是我在照着这类答案练手时反复撞上的，每条按现象、原因、解决走一遍。

5.1 赋值写成判断：if(k=0) 这类写法为什么能编译通过

现象：填空题那道if(k=0){flag=0;} else {flag=1;}，输出是k=0#flag=1，很多人第一反应是“0 不是假吗，为什么进了 else”。

原因：k=0是赋值表达式，不是比较。它把 0 赋给k，整个表达式的值取赋值后的k，也就是 0，而 0 作为条件按假处理，所以走else，flag被置 1。整段代码语法完全合法，只是行为不是作者本意。

解决：开-Wall，编译器会给suggest parentheses around assignment used as truth value这条告警。如果确实需要在条件里做赋值，写成if ((k = 0) != 0)显式加括号，让意图一目了然。另一种习惯是把常量放左边写if (0 == k)，漏写等号会直接变成对常量赋值，编译期就报错，不用等到运行时才暴露。

5.2 花括号、分号与格式串：三个编译期就该拦住的事故

现象一：只改了一行，结果报出一屏幕错误，几十行都标红。

原因：大概率是漏了一个右花括号，编译器在后面的代码里找不到结构终点，一路报到底。这类错误第一行的位置往往是准的，后面的都是连带的。

现象二：printf(Welcome to You! \n")这行缺了左边引号、末尾也没有分号，编译直接失败。

原因：stdin里的字符必须是字符串常量，缺引号会被当成标识符解析，找不到声明就报undeclared identifier，后面跟着一串语法错误。原题问“改正几处”答案是 2，一处是引号，一处是分号。

解决：改编译错误只改第一个，改完重新编译再看，不要对着整屏错误一起猜。另外养成一个习惯——每写完一个{}块立刻配平，编辑器自动补全关掉有点自虐，但至少写完要跑一次格式化。

现象三：预处理命令末尾加了分号，#include <math.h>;

本文还有配套的精品资源，点击获取