《C语言程序设计》期末试卷 (精选12)

一、选择题（每小题 1 分，共 15 分）

要求： 根据题目从 A、B、C、D 中选择一个正确的选项

1. 以下 4 组用户定义标识符中，全部合法的一组是（ ）
   • A. _main, enclude, sn
   • B. If, -max, turbo
   • C. txt, REAL, 3COM
   • D. int, k_2, _001

查看答案与解析

答案：A

解析： A 中 _main、enclude、sn 均以字母或下划线开头，符合标识符命名规则。B 中 -max 含非法字符 -；C 中 3COM 以数字开头不合法；D 中 int 是关键字，不能作为标识符。

---

难度: ⭐ 考点: #标识符 #命名规则

💡 学习锦囊

📖 相关公式与知识点:

• 标识符由字母、数字、下划线组成。
• 首字符必须是字母或下划线，不能是数字。
• 区分大小写，不能使用关键字。

思路分析

逐一检查每组中的每个标识符，只要有一个不合法，整组就不符合"全部合法"的要求。

易错点

• 误以为 _main 是关键字（main 不是关键字，是函数名）。
• 忽略 - 是非法字符。
• 误以为 If 是关键字（If 不是关键字，if 才是，C 语言区分大小写）。

🔄 举一反三

1. 以下哪个是合法的 C 语言标识符？
   • A. 2name
   • B. _name
   • C. float
   • D. a-b
   查看练习答案与解析

   答案：B 解析：_name 以下划线开头合法；2name 以数字开头不合法；float 是关键字；a-b 含非法字符 -。

2. 表达式_____的值是整数类型。
   • A. 15/2+2.0
   • B. 15/2
   • C. 25/5.0
   • D. 0.5*10

查看答案与解析

答案：B

解析：15/2 是两个整数相除，结果为整数 7（截断小数部分）。A 中 15/2+2.0 = 7+2.0 = 9.0（double 类型）；C 中 25/5.0 = 5.0（double 类型）；D 中 0.5*10 = 5.0（double 类型）。

---

难度: ⭐ 考点: #整数除法 #类型转换

💡 学习锦囊

📖 相关公式与知识点:

• 整数/整数 = 整数（截断小数）。
• 只要有一个操作数是浮点型，结果就是浮点型。

思路分析

判断表达式类型的关键是看操作数中是否包含浮点数。

易错点

• 误以为 15/2 结果是 7.5。

🔄 举一反三

1. 表达式 10/3 的值是多少？是什么类型？
   查看练习答案与解析

   答案：3，int 类型 解析：两个整数相除，结果为整数 3。

3. 以下选项中，不能作为合法常量的是_____。
   • A. 1.234e04
   • B. 1.234e0.4
   • C. 1.234e+4
   • D. 1.234e0

查看答案与解析

答案：B

解析： 科学计数法（浮点常量）的格式为：尾数e指数 或 尾数E指数，其中指数部分必须是整数。B 中 e0.4 的指数为小数 0.4，不合法。A 中 e04 指数为 4，合法；C 中 e+4 指数为 +4，合法；D 中 e0 指数为 0，合法。

---

难度: ⭐ 考点: #浮点常量 #科学计数法

💡 学习锦囊

📖 相关公式与知识点:

• 科学计数法：aEb 表示 $a \times 10^b$。
• 指数 b 必须是整数（可为正负），不能是小数。

思路分析

记住"e 后面必须是整数"即可快速判断。

易错点

• 误以为 e0 不合法（指数为 0 是合法的）。

🔄 举一反三

1. 以下哪个是合法的 C 语言浮点常量？
   • A. 1.2e
   • B. 1.2e1.5
   • C. 1.2e-3
   • D. e5
   查看练习答案与解析

   答案：C 解析：1.2e-3 指数为 -3（整数），合法。A 缺少指数；B 指数为小数；D 缺少尾数。

4. 设有以下定义：

int a=0;
double b=1.25;
char c='A';
#define d 2

则下面语句中错误的是（ ）。

• A. a++;
• B. b++;
• C. c++;
• D. d++;

查看答案与解析

答案：D

解析：d 是通过 #define 定义的宏常量，在预处理阶段会被替换为字面值 2。d++ 展开后变为 2++，而常量不能进行自增操作，编译报错。A、B、C 中的 a、b、c 都是变量，可以自增。

---

难度: ⭐ 考点: #宏定义 #自增运算符

💡 学习锦囊

📖 相关公式与知识点:

• #define 定义的是符号常量，在预处理阶段进行文本替换。
• 自增/自减运算符只能作用于变量（左值），不能作用于常量。

思路分析

宏常量不是变量，不能修改。区分 const int d=2;（const 变量，也不能自增）和 #define d 2（宏常量）。

易错点

• 混淆宏常量和变量，误以为 d 是变量。

🔄 举一反三

1. 若将 #define d 2 改为 int d=2;，d++ 是否合法？
   查看练习答案与解析

   答案：合法 解析：d 是 int 型变量，可以进行自增操作，d++ 后 d 变为 3。

5. 算法具有五个特性，以下选项中不属于算法特性的是_____。
   • A. 有限性
   • B. 有效性
   • C. 确定性
   • D. 简洁性

查看答案与解析

答案：D

解析： 算法的五个基本特性是：有穷性（有限性）、确定性、可行性（有效性）、输入、输出。简洁性不是算法的基本特性，虽然好的算法通常追求简洁，但它不是必要条件。

---

难度: ⭐ 考点: #算法特性

💡 学习锦囊

📖 相关公式与知识点:

• 算法五大特性：有穷性、确定性、可行性、输入、输出。
• 好算法的评价标准：正确性、可读性、健壮性、效率与低存储量。

思路分析

区分"算法的基本特性"和"好算法的评价标准"——简洁性属于后者。

易错点

• 将"简洁性"与"确定性"或"有穷性"混淆。

🔄 举一反三

1. 以下哪项是算法的基本特性？
   • A. 美观性
   • B. 有穷性
   • C. 简洁性
   • D. 可移植性
   查看练习答案与解析

   答案：B 解析：有穷性是算法的五大基本特性之一。

6. 为求出 s=10! 的值，则变量 s 的类型应当为_____。
   • A. int
   • B. long
   • C. unsigned
   • D. 以上三种类型均可

查看答案与解析

答案：D

解析： 10! = 10×9×8×7×6×5×4×3×2×1 = 3,628,800。在现代 32 位及以上系统中，int 的范围为 -2,147,483,648~2,147,483,647，long 和 unsigned int 的范围均不小于 int，三种类型均可容纳 3,628,800。本题按现代 32 位及以上系统作答。

---

难度: ⭐ 考点: #数据类型范围 #阶乘

💡 学习锦囊

📖 相关公式与知识点:

• 16 位系统：int 范围 -32768~32767，unsigned int 范围 0~65535（10! 无法容纳）。
• 32 位及以上系统：int/long 范围约 ±21 亿（10! 可以容纳）。

思路分析

先计算 10! 的值，再与各类型的取值范围比较。注意不同系统环境下 int 的位数不同。

易错点

• 按 16 位系统考虑，10! 超出 int 和 unsigned 范围，应选 B(long)。
• 本题按现代 32 位及以上系统作答，选 D。

🔄 举一反三

1. 求 20! 的值，变量应选用什么类型？
   查看练习答案与解析

   答案：long long 或 double解析：20! ≈ 2.43×10^18，超出 32 位 int/long 范围，需用 64 位整型或浮点型。

7. C 语言程序中，若对函数类型未加显示说明，则函数的隐含类型是_____。
   • A. void
   • B. double
   • C. int
   • D. char

查看答案与解析

答案：C

解析： 在 C89/C90 标准中，若函数未显式声明返回类型，编译器默认其为 int 类型。例如 func() { return 1.5; } 会被视为返回 int 类型。C99 及之后的标准已废弃此规则，但考试仍常考此知识点。

---

难度: ⭐ 考点: #函数默认类型 #C标准

💡 学习锦囊

📖 相关公式与知识点:

• C89 标准：函数默认返回 int。
• C99 及之后：必须显式声明返回类型，否则警告/报错。

思路分析

这是 C 语言历史遗留问题，记住"默认 int"即可。

易错点

• 误以为默认类型是 void。

🔄 举一反三

1. 以下函数定义在 C89 标准下返回什么类型？

   add(a, b) { return a + b; }

   查看练习答案与解析

   答案：int 解析：未声明返回类型，默认为 int。

8. 在 C 语言中，"***123***"是合法的_____表示。
   • A. 字符
   • B. 浮点数
   • C. 字符串
   • D. A,B,C 都不对

查看答案与解析

答案：C

解析： 双引号 "" 括起来的内容是字符串常量。字符串以 '\0' 结尾，"***123***" 实际存储为 ***123***\0，共 10 个字节。单引号 '' 括起来的才是字符常量。

---

难度: ⭐ 考点: #字符串常量 #字符常量

💡 学习锦囊

📖 相关公式与知识点:

• 单引号 'A' → 字符常量（1 字节）。
• 双引号 "A" → 字符串常量（2 字节：'A' + '\0'）。

思路分析

区分单引号和双引号是判断字符/字符串的关键。

易错点

• 混淆字符常量和字符串常量的表示方法。

🔄 举一反三

1. sizeof("***123***") 的值是多少？
   查看练习答案与解析

   答案：10 解析：9 个可见字符 + 1 个结束符 '\0' = 10 字节。

9. 设变量说明为：int a=30, b=20, c=10, d=a>b>c; 则 d 的值是_____。
   • A. 0
   • B. 1
   • C. 30
   • D. 10

查看答案与解析

答案：A

解析： 关系运算符是左结合的。a>b>c 先计算 a>b（30>20 为真，值为 1），再计算 1>c（1>10 为假，值为 0）。所以 d=0。注意：C 语言中 a>b>c 不等价于数学中的 a>b && b>c。

---

难度: ⭐⭐ 考点: #关系运算符 #运算符结合性

💡 学习锦囊

📖 相关公式与知识点:

• 关系运算符左结合。
• 关系表达式结果为 1（真）或 0（假）。

思路分析

C 语言不支持链式比较，a>b>c 被解析为 (a>b)>c。

易错点

• 按数学思维理解为 a>b && b>c，误选 B。

🔄 举一反三

1. int d = a>b && b>c; 中 d 的值是多少？（a=30,b=20,c=10）
   查看练习答案与解析

   答案：1 解析：30>20 为真且 20>10 为真，逻辑与结果为 1。

10. _____是 C 语言的标准函数名。
    • A. putchar
    • B. case
    • C. while
    • D. long

查看答案与解析

答案：A

解析：putchar 是标准库函数（在 stdio.h 中声明），用于输出单个字符。B 中 case 是关键字（switch 语句）；C 中 while 是关键字（循环语句）；D 中 long 是类型关键字。

---

难度: ⭐ 考点: #标准库函数 #关键字

💡 学习锦囊

📖 相关公式与知识点:

• 常用标准 I/O 函数：putchar、getchar、printf、scanf、puts、gets。
• C 语言共 32 个关键字（C89）。

思路分析

区分关键字（保留字）和库函数名——关键字不能作为标识符，库函数名可以（但不建议）。

易错点

• 误以为 case、while 是函数名。

🔄 举一反三

1. 以下哪个是 C 语言关键字？
   • A. main
   • B. include
   • C. switch
   • D. printf
   查看练习答案与解析

   答案：C 解析：switch 是关键字；main 是函数名；include 是预处理指令；printf 是库函数。

11. 设已定义 k 是 int 型变量，则下面循环执行体执行的次数是_____。

k=10;
while(k=0) k=k-1;

- A. 执行 10 次
- B. 无限循环
- C. 一次也不执行
- D. 执行一次

查看答案与解析

答案：C

解析：while(k=0) 中是赋值表达式而非条件判断。k=0 的值为 0（赋值表达式的值等于被赋的值），条件为假，循环体一次也不执行。若改为 while(k==0) 则是比较运算，但 k 初始为 10，条件也为假。注意区分 =（赋值）和 ==（等于）。

---

难度: ⭐⭐ 考点: #赋值与比较 #while循环

💡 学习锦囊

📖 相关公式与知识点:

• = 是赋值运算符，== 是等于比较运算符。
• 赋值表达式的值等于被赋的值。

思路分析

看到 while(k=0) 要立刻反应：这是把 0 赋给 k，条件为假。

易错点

• 将 k=0 误读为 k==0，得出错误结论。

🔄 举一反三

1. 若改为 while(k=1) k=k-1;，循环执行多少次？
   查看练习答案与解析

   答案：无限循环 解析：k=1 的值始终为 1（真），且每次循环 k 被重新赋值为 1，条件永远为真。

12. 设 int 类型的数据长度为 2 字节，则 unsigned int 类型数据的取值范围是_____。
    • A. 0~255
    • B. 0~65535
    • C. -256~255
    • D. -32768~32767

查看答案与解析

答案：B

解析： 2 字节 = 16 位。unsigned int 无符号位，全部 16 位用于表示数值，取值范围为 0 ~ 2^16-1 = 0 ~ 65535。A 是 1 字节无符号范围；C 无意义；D 是 signed int（有符号）的范围。

---

难度: ⭐ 考点: #数据类型范围 #unsigned

💡 学习锦囊

📖 相关公式与知识点:

• n 位无符号整数范围：0 ~ 2^n - 1。
• n 位有符号整数范围：-2^(n-1) ~ 2^(n-1) - 1。

思路分析

2 字节 = 16 位，代入公式 2^16 - 1 = 65535。

易错点

• 混淆有符号和无符号的范围。

🔄 举一反三

1. 设 int 类型为 2 字节，signed int 的取值范围是多少？
   查看练习答案与解析

   答案：-32768 ~ 32767 解析：16 位有符号，最高位为符号位，范围 -2^15 ~ 2^15-1。

13. 在一个源文件中定义的全局变量的作用域为_____。
    • A. 本文件的全部范围
    • B. 本程序的全部范围
    • C. 本函数的全部范围
    • D. 从定义该变量开始至本文件结束

查看答案与解析

答案：D

解析： 全局变量（外部变量）的作用域从定义位置开始，到本源文件结束。在定义之前的函数若想使用该全局变量，需用 extern 声明。A 错误因为定义之前的代码不能直接访问；B 错误因为其他文件需 extern 声明才能访问。

---

难度: ⭐ 考点: #全局变量 #作用域

💡 学习锦囊

📖 相关公式与知识点:

• 局部变量作用域：定义处到所在块结束。
• 全局变量作用域：定义处到文件结束（其他文件可用 extern 扩展）。

思路分析

记住"从定义处开始"这个关键限定。

易错点

• 误以为全局变量在整个文件任何位置都可见。

🔄 举一反三

1. 若在文件开头用 extern int x; 声明，x 的作用域是什么？
   查看练习答案与解析

   答案：从声明处到文件结束 解析：extern 声明扩展了全局变量的可见范围。

14. 设有如下说明：

typedef struct ST
{
    long a;
    int b;
    char c[2];
} NEW;

则下面叙述中正确的是_____。

- A. 以上说明表达式非法
- B. ST 是一个结构体类型
- C. NEW 是一个结构体类型
- D. NEW 是一个结构体变量

查看答案与解析

答案：C

解析：typedef struct ST { ... } NEW; 定义了一个结构体类型 struct ST，并用 typedef 为其创建别名 NEW。因此 NEW 是一个结构体类型名（等价于 struct ST），可以用 NEW var; 定义变量。B 不准确——ST 是结构体标签名，struct ST 才是完整类型名。

---

难度: ⭐⭐ 考点: #typedef #结构体

💡 学习锦囊

📖 相关公式与知识点:

• typedef 原类型 新别名; 为已有类型创建别名。
• struct ST 是类型，ST 是标签名。

思路分析

typedef 创建的是类型别名，不是变量。NEW 是类型名，不是变量名。

易错点

• 误以为 NEW 是变量名而选 D。
• 混淆标签名 ST 和类型名 struct ST。

🔄 举一反三

1. 如何用 NEW 定义一个结构体变量 s？
   查看练习答案与解析

   答案：NEW s; 或 struct ST s;解析：NEW 是 struct ST 的别名，两种写法等价。

15. 设有一共用体变量定义如下：

union data
{
    long w;
    float x;
    int y;
    char z;
} try;

执行赋值语句 try.w=123456; try.y=65; try.z='*'; try.x=3.1416; 后，共用体变量 try 的值是_____。

- A. 123456
- B. 65
- C. 3.1416
- D. '*'

查看答案与解析

答案：C

解析： 共用体（union）的所有成员共享同一块内存空间，同一时刻只能存储一个成员的值。最后执行的赋值语句是 try.x=3.1416;，因此当前有效成员是 x，值为 3.1416。之前赋的值都被覆盖了。

---

难度: ⭐ 考点: #共用体 #union

💡 学习锦囊

📖 相关公式与知识点:

• 共用体所有成员共享同一内存地址。
• 共用体大小 = 最大成员的大小。
• 最后赋值的成员有效。

思路分析

共用体是"覆盖式"存储，新值覆盖旧值。看最后一条赋值语句即可。

易错点

• 误以为所有成员的值同时存在。

🔄 举一反三

1. sizeof(union data) 的值是多少？（假设 long=4, float=4, int=2, char=1）
   查看练习答案与解析

   答案：4 解析：共用体大小为最大成员的大小，long 和 float 均为 4 字节。

二、填空题（每空 1 分，共 10 分）

1. 结构化程序设计所规定的三种基本控制结构是顺序结构、_____和_____。

查看答案与解析

答案： 选择结构、循环结构

解析： 结构化程序设计的三种基本控制结构是：顺序结构、选择结构（分支结构）、循环结构。任何复杂程序都可以由这三种结构组合而成。

---

难度: ⭐ 考点: #结构化程序设计 #控制结构

💡 学习锦囊

📖 相关公式与知识点:

• 顺序结构：按书写顺序依次执行。
• 选择结构：if-else、switch。
• 循环结构：while、do-while、for。

思路分析

这是基础概念题，记住"顺序、选择、循环"即可。

🔄 举一反三

1. goto 语句属于哪种基本控制结构？
   查看练习答案与解析

   答案：不属于三种基本结构 解析：goto 是无条件跳转，结构化程序设计主张限制使用 goto。

2. 整型变量 a,b,c 分别为 3,4,5，计算表达式 a=16+(b++)-(++c) 后，a 的值是_____。

查看答案与解析

答案： 14

解析：b++ 后缀自增：先用 b 的值 4 参与运算，然后 b 变为 5。++c 前缀自增：c 先变为 6，再用 6 参与运算。所以 a = 16 + 4 - 6 = 14。

---

难度: ⭐⭐ 考点: #自增运算符 #表达式求值

💡 学习锦囊

📖 相关公式与知识点:

• 前缀 ++x：先自增，后使用。
• 后缀 x++：先使用，后自增。

思路分析

逐项分析：b++ 贡献 4，++c 贡献 6，代入计算。

易错点

• 混淆前缀和后缀的执行顺序。

🔄 举一反三

1. 若表达式改为 a=16+(++b)-(c++)，a 的值是多少？
   查看练习答案与解析

   答案：16 解析：初始 b=4, c=5。++b 先自增后使用，b 变为 5，使用 5；c++ 先使用后自增，使用 5，c 变为 6。a = 16 + 5 - 5 = 16。

3. 有以下程序：

main()
{
    int x=102, y=012;
    printf("%d,%d\n",x,y);
}

执行后输出结果是_____。

查看答案与解析

答案： 102,10

解析：x=102 是十进制数，直接输出 102。y=012 以 0 开头，是八进制数，转换为十进制：1×8^1 + 2×8^0 = 8+2 = 10。%d 以十进制格式输出，所以 y 输出 10。

---

难度: ⭐ 考点: #八进制 #printf格式

💡 学习锦囊

📖 相关公式与知识点:

• 八进制以 0 开头，十六进制以 0x 开头。
• %d 始终以十进制输出，%o 以八进制输出，%x 以十六进制输出。

思路分析

识别 012 是八进制数是关键，然后转换为十进制。

易错点

• 忽略前导 0，将 012 当作十进制 12。

🔄 举一反三

1. printf("%d", 0x12); 的输出结果是什么？
   查看练习答案与解析

   答案：18 解析：0x12 是十六进制，1×16^1 + 2×16^0 = 16+2 = 18。

4. 有如下程序段：

int *p,a=10,b=1;
p=&a;
a=*p+b;

执行该程序段后，a 的值为_____。

查看答案与解析

答案： 11

解析：p=&a 使指针 p 指向变量 a。*p 是解引用，取 p 所指向变量的值，即 a 的值 10。a=*p+b 即 a = 10 + 1 = 11。

---

难度: ⭐ 考点: #指针 #解引用

💡 学习锦囊

📖 相关公式与知识点:

• & 取地址运算符，* 解引用运算符。
• *p 等价于 p 所指向的变量。

思路分析

p 指向 a，所以 *p 就是 a 的值。代入计算即可。

易错点

• 混淆 *p（解引用）和 p（地址）。

🔄 举一反三

1. 若将 a=*p+b 改为 *p=*p+b;，a 的值是多少？
   查看练习答案与解析

   答案：11 解析：*p 就是 a，*p=*p+b 等价于 a=a+b，结果也是 11。

5. 若有定义语句 int a[3][5]，则表示 a 是一个整型数组，它包含有_____个元素。

查看答案与解析

答案： 15

解析： 二维数组 a[3][5] 有 3 行 5 列，元素总数 = 3 × 5 = 15。

---

难度: ⭐ 考点: #二维数组 #数组元素

💡 学习锦囊

📖 相关公式与知识点:

• 二维数组元素总数 = 行数 × 列数。
• 内存中按行优先存储。

思路分析

直接乘法：3 行 × 5 列 = 15 个元素。

🔄 举一反三

1. int a[2][3][4] 包含多少个元素？
   查看练习答案与解析

   答案：24 解析：三维数组元素总数 = 2×3×4 = 24。

6. 开辟一个 16 字节的内存区，用来存储一个字符串，并将此存储区首地址送入 p（指向字符型数据指针变量）的语句为_____。

查看答案与解析

答案： p = (char *)malloc(16);

解析：malloc(16) 在堆上分配 16 字节内存，返回 void* 类型指针。由于 p 是 char* 类型，需要强制类型转换 (char *)。在 C 中也可省略强制转换（但不推荐）。需 #include <stdlib.h>。

---

难度: ⭐⭐ 考点: #malloc #动态内存分配

💡 学习锦囊

📖 相关公式与知识点:

• malloc(size) 分配 size 字节内存，返回 void*。
• 使用前需 #include <stdlib.h>。
• 使用后需 free(p) 释放。

思路分析

动态分配内存的标准写法：(目标类型 *)malloc(字节数)。

易错点

• 忘记强制类型转换。
• 忘记包含头文件 <stdlib.h>。

🔄 举一反三

1. 如何用 calloc 分配 16 字节内存给 char* p？
   查看练习答案与解析

   答案：p = (char *)calloc(16, sizeof(char));解析：calloc(n, size) 分配 n 个大小为 size 的元素并初始化为 0。

7. 定义一个指针变量 fun，指向返回值为 double 类型的函数的指针变量的说明语句为_____。

查看答案与解析

答案： double (*fun)();

解析： 函数指针的声明格式：返回类型 (*指针名)(参数列表);。double (*fun)() 声明 fun 是一个指针，指向返回 double 类型、参数未指定的函数。括号 (*fun) 必不可少，否则 double *fun() 会被解析为声明一个返回 double* 的函数。

---

难度: ⭐⭐ 考点: #函数指针 #指针声明

💡 学习锦囊

📖 相关公式与知识点:

• 函数指针声明：返回类型 (*指针名)(参数类型列表);
• * 和指针名必须用括号括起来。

思路分析

区分 double (*fun)()（函数指针）和 double *fun()（返回指针的函数）。

易错点

• 漏掉括号写成 double *fun();，含义完全不同。

🔄 举一反三

1. 声明一个函数指针 p，指向返回 int、接受两个 int 参数的函数。
   查看练习答案与解析

   答案：int (*p)(int, int);解析：参数类型写在第二个括号内。

8. 有以下程序：

main()
{
    unsigned char a,b;
    a=4|3;
    b=4&3;
    printf("%d %d\n",a,b);
}

程序运行后的输出结果是_______。

查看答案与解析

答案： 7 0

解析： 按位或 |：4(00000100) | 3(00000011) = 7(00000111)。按位与 &：4(00000100) & 3(00000011) = 0(00000000)。所以输出 7 0。

---

难度: ⭐ 考点: #位运算 #按位或 #按位与

💡 学习锦囊

📖 相关公式与知识点:

• | 按位或：对应位有一个为 1 则结果为 1。
• & 按位与：对应位都为 1 结果才为 1。
• ^ 按位异或：对应位不同则结果为 1。

思路分析

将十进制转为二进制，逐位进行运算，再转回十进制。

易错点

• 混淆按位运算符 |、& 和逻辑运算符 ||、&&。

🔄 举一反三

1. 4^3 的值是多少？
   查看练习答案与解析

   答案：7 解析：4(100) ^ 3(011) = 7(111)。

9. 若有说明语句和执行语句：int a=7,b=12,c=a&b; 变量 c 的值是_____。

查看答案与解析

答案： 4

解析： 7 的二进制：0111，12 的二进制：1100。按位与：0111 & 1100 = 0100 = 4。

---

难度: ⭐ 考点: #位运算 #按位与

💡 学习锦囊

📖 相关公式与知识点:

• 按位与常用于"清零"或"取特定位"。
• 任何数与 0 按位与结果为 0。

思路分析

逐位对齐，只有对应位都为 1 时结果才为 1。

🔄 举一反三

1. 7|12 的值是多少？
   查看练习答案与解析

   答案：15 解析：0111 | 1100 = 1111 = 15。

三、将下面数学表达式写成 C 语言表达式（每小题 2 分，共 10 分）

1. $\log_{10}x + 2e^x$

查看答案与解析

答案： log10(x) + 2*exp(x)

解析：log10(x) 计算以 10 为底的对数，exp(x) 计算 e^x。需 #include <math.h>。

---

难度: ⭐ 考点: #数学函数 #math.h

💡 学习锦囊

📖 相关公式与知识点:

• log10(x) → $\log_{10}x$
• exp(x) → $e^x$
• log(x) → $\ln x$
• pow(x,y) → $x^y$

思路分析

将数学符号一一映射到 C 语言数学库函数。

🔄 举一反三

1. 将 $\ln x + \sqrt{x}$ 写成 C 语言表达式。
   查看练习答案与解析

   答案：log(x) + sqrt(x)解析：log(x) 是自然对数，sqrt(x) 是平方根。

2. $10 < x^2 + y^2 < 30$

查看答案与解析

答案： x*x+y*y>10 && x*x+y*y<30

解析： C 语言不支持链式比较，必须拆分为两个条件用 && 连接。x*x 比 pow(x,2) 更高效。

---

难度: ⭐ 考点: #逻辑表达式 #链式比较

💡 学习锦囊

📖 相关公式与知识点:

• C 语言不支持 a < b < c 形式的链式比较。
• 必须写成 a < b && b < c。

思路分析

数学中的连续不等式在 C 中必须拆分为逻辑与表达式。

易错点

• 直接写成 10 < x*x+y*y < 30，这在 C 中含义完全不同。

🔄 举一反三

1. 将 $1 \le x \le 10$ 写成 C 语言表达式。
   查看练习答案与解析

   答案：x>=1 && x<=10解析：注意 ≤ 对应 <=，≥ 对应 >=。

3. $\frac{4a + 3b}{6cd}$

查看答案与解析

答案： (4*a+3*b)/(6*c*d)

解析： 分子和分母都需要用括号包裹，确保运算顺序正确。分母 6*c*d 中乘法可省略括号（乘法结合律），但分子 4*a+3*b 的括号不能省略。

---

难度: ⭐ 考点: #算术表达式 #运算符优先级

💡 学习锦囊

📖 相关公式与知识点:

• 乘除法优先级高于加减法。
• 分子分母各用括号包裹，避免歧义。

思路分析

分数线相当于除法，分子分母各自加括号。

易错点

• 写成 4*a+3*b/6*c*d，由于优先级问题结果完全不同。

🔄 举一反三

1. 将 $\frac{a+b}{c-d}$ 写成 C 语言表达式。
   查看练习答案与解析

   答案：(a+b)/(c-d)解析：分子分母各自加括号。

4. $\sqrt{b^2 - 4ac}$

查看答案与解析

答案： sqrt(b*b-4*a*c)

解析：sqrt() 计算平方根。b*b 表示 b 的平方，4*a*c 中乘号不能省略。需 #include <math.h>。

---

难度: ⭐ 考点: #sqrt函数 #数学表达式

💡 学习锦囊

📖 相关公式与知识点:

• sqrt(x) 返回 x 的平方根。
• 乘法运算符 * 不能省略。

思路分析

这是求根公式中的判别式部分，注意 4ac 在 C 中必须写成 4*a*c。

易错点

• 写成 4ac（缺少乘号），编译报错。

🔄 举一反三

1. 将 $\sqrt[3]{x}$ 写成 C 语言表达式。
   查看练习答案与解析

   答案：pow(x, 1.0/3) 或 cbrt(x)解析：C 标准库无直接立方根函数（C99 有 cbrt），可用 pow 实现。

5. $x^y + xy$

查看答案与解析

答案： pow(x,y) + x*y

解析：pow(x,y) 计算 x 的 y 次方。xy 在数学中表示 x×y，在 C 中必须写成 x*y。需 #include <math.h>。

---

难度: ⭐ 考点: #pow函数 #乘法运算符

💡 学习锦囊

📖 相关公式与知识点:

• pow(x, y) 返回 $x^y$（double 类型）。
• C 语言中乘法必须显式使用 * 运算符。

思路分析

区分 x^y（幂运算，用 pow）和 xy（乘法，用 *）。

易错点

• 将 xy 写成 xy（编译器视为一个标识符）。
• 用 x^y 表示幂运算（^ 是按位异或）。

🔄 举一反三

1. 将 $2^x$ 写成 C 语言表达式。
   查看练习答案与解析

   答案：pow(2, x)解析：底数和指数都可以是变量或常量。

四、写出下面程序的运行结果（每小题 3 分，共 15 分）

1. 程序阅读

#include "stdio.h"
main()
{
    int a1,a2,a3;
    a1=a2=65;
    a3=97;
    printf("%d,%d,%d\n",a1,a2+1,a3+1);
    printf("%c,%c,%c\n",a1,a2,a3);
}

问题 1: 写出程序的运行结果。

查看答案与解析

答案：

65,66,98
A,A,a

解析： 第一行 %d 以整数输出：a1=65，a2+1=66，a3+1=98。第二行 %c 以字符输出：65 对应 ASCII 字符 'A'，97 对应 'a'。

---

难度: ⭐ 考点: #printf格式 #ASCII码

💡 学习锦囊

📖 相关公式与知识点:

• %d 以十进制整数输出，%c 以字符输出。
• ASCII 码：'A'=65，'a'=97。

思路分析

同一变量的值不变，但用不同格式符输出会得到不同结果。

易错点

• 混淆 %d 和 %c 的输出效果。

🔄 举一反三

1. 若 printf("%c", 66); 输出什么？
   查看练习答案与解析

   答案：B 解析：66 是 'B' 的 ASCII 码。

2. 程序阅读

main()
{
    int i,j,a[3][4]={1,2,3,4,2,3,4,5,3,4,5,6};
    for(i=0;i<3;i++)
    {
        for(j=0;j<=i;j++)
            printf("%4d",a[j][i]);
        printf("\n");
    }
}

问题 2: 写出程序的运行结果。

查看答案与解析

答案：

   1
   2   3
   3   4   5

解析： 二维数组按行初始化：a[0]={1,2,3,4}，a[1]={2,3,4,5}，a[2]={3,4,5,6}。外层 i 控制列，内层 j 控制行（j≤i）。i=0 时输出 a[0][0]=1；i=1 时输出 a[0][1]=2, a[1][1]=3；i=2 时输出 a[0][2]=3, a[1][2]=4, a[2][2]=5。

---

难度: ⭐⭐ 考点: #二维数组 #嵌套循环

💡 学习锦囊

📖 相关公式与知识点:

• 二维数组初始化：按行优先顺序填充。
• a[j][i] 中 j 是行，i 是列。

思路分析

注意循环中输出的是 a[j][i]（行索引 j，列索引 i），不是常规的 a[i][j]。

易错点

• 按 a[i][j] 理解，得出错误的输出结果。

🔄 举一反三

1. 若将 a[j][i] 改为 a[i][j]，输出结果是什么？
   查看练习答案与解析

   答案：

      1
      2   3
      3   4   5

   解析：a[0][0]=1；a[1][0]=2, a[1][1]=3；a[2][0]=3, a[2][1]=4, a[2][2]=5。结果相同，因为此数组恰好对称。

3. 程序阅读

main()
{
    char a[]="abcdefg",b[10]="abcdefg";
    printf("%d %d\n",sizeof(a),sizeof(b));
}

问题 3: 写出程序的运行结果。

查看答案与解析

答案： 8 10

解析：sizeof(a)：数组 a 未指定大小，由初始化字符串确定。"abcdefg" 有 7 个字符 + '\0' = 8 字节。sizeof(b)：数组 b 显式声明大小为 10，无论初始化内容如何，sizeof 返回 10。

---

难度: ⭐⭐ 考点: #sizeof #字符数组

💡 学习锦囊

📖 相关公式与知识点:

• sizeof(数组名) 返回数组总字节数。
• 未指定大小的数组，大小由初始化决定。
• 显式指定大小的数组，sizeof 返回声明的大小。

思路分析

区分"由初始化决定大小"和"由声明决定大小"两种情况。

易错点

• 误以为 sizeof(a) 也是 10。
• 忘记字符串末尾的 '\0'。

🔄 举一反三

1. strlen(a) 和 strlen(b) 的值分别是多少？
   查看练习答案与解析

   答案：都是 7 解析：strlen 返回字符串长度（不含 '\0'），两者内容相同。

4. 程序阅读

main()
{
    FILE *fp;
    int i,k=0,n=0;
    fp=fopen("d1.dat","w");
    for(i=1;i<4;i++)
        fprintf(fp,"%d",i);
    fclose(fp);
    fp=fopen("d1.dat","r");
    fscanf(fp,"%d%d",&k,&n);
    printf("%d %d\n",k,n);
    fclose(fp);
}

问题 4: 写出程序的运行结果。

查看答案与解析

答案： 123 0

解析： 写入文件时 fprintf(fp,"%d",i) 循环 3 次，依次写入 1、2、3，没有空格分隔，文件内容为 "123"。读取时 fscanf(fp,"%d%d",&k,&n) 将 "123" 整体作为一个整数读给 k（k=123），n 没有读到值，保持初始值 0。

---

难度: ⭐⭐⭐ 考点: #文件操作 #fprintf #fscanf

💡 学习锦囊

📖 相关公式与知识点:

• fprintf 格式化写入文件，fscanf 格式化读取。
• 连续写入无分隔符时，数据会拼接在一起。

思路分析

关键点：写入时没有加空格或换行，导致读取时整个内容被当作一个数。

易错点

• 误以为每次写入会自动添加分隔符。
• 误以为 n 能读到值。

🔄 举一反三

1. 若将 fprintf(fp,"%d",i) 改为 fprintf(fp,"%d ",i)（加空格），输出结果是什么？
   查看练习答案与解析

   答案：1 2解析：文件内容为 "1 2 3 "，fscanf 读取 k=1, n=2。

5. 程序阅读

main()
{
    int a[]={1,2,3,4,5,6},*p;
    p=a;
    *(p+3)+=2;
    printf("%d,%d\n",*p,*(p+3));
}

问题 5: 写出程序的运行结果。

查看答案与解析

答案： 1,6

解析：p=a 使 p 指向数组首元素 a[0]。*(p+3) 等价于 a[3]，即第 4 个元素（值为 4）。*(p+3)+=2 等价于 a[3]=a[3]+2，a[3] 变为 6。*p 是 a[0]=1，*(p+3) 是 a[3]=6。

---

难度: ⭐⭐ 考点: #指针运算 #指针与数组

💡 学习锦囊

📖 相关公式与知识点:

• *(p+n) 等价于 p[n] 等价于 a[n]（当 p=a 时）。
• 指针加减整数 n 表示移动 n 个元素（不是 n 字节）。

思路分析

*(p+3)+=2 修改了数组元素 a[3] 的值，后续访问会看到修改后的值。

易错点

• 误以为 *(p+3) 是 a[2]（索引从 0 开始，+3 是第 4 个元素）。

🔄 举一反三

1. 若 p=a+2;，则 *p 和 *(p+3) 的值分别是多少？
   查看练习答案与解析

   答案：3, 6 解析：p 指向 a[2]=3，*(p+3) 即 a[5]=6。

五、编程题（任选 5 题，每题 10 分，共 50 分）

1. 级数求和

题目: 编写程序，计算并输出下面级数中前 n（设 n=20）项的和。

$1 \times 2 + 2 \times 3 + 3 \times 4 + 4 \times 5 + \dots + n \times (n+1) + \dots$

查看答案与解析

参考答案：

#include <stdio.h>

void main()
{
    int i, n = 20;
    long sum = 0;
    
    for (i = 1; i <= n; i++)
    {
        sum += i * (i + 1);
    }
    
    printf("前%d项的和为: %ld\n", n, sum);
}

输出结果: 前20项的和为: 3080

解析： 通项公式为 $a_i = i \times (i+1)$，用 for 循环累加前 20 项。注意 sum 用 long 类型防止溢出。

---

难度: ⭐⭐ 考点: #循环 #级数求和

💡 学习锦囊

📖 相关公式与知识点:

• 通项公式：$a_i = i(i+1)$
• 累加模式：sum += 通项

思路分析

先找出通项公式，再用循环逐项累加。注意数据类型选择，防止溢出。

🔄 举一反三

1. 求前 n 项 $1^2 + 2^2 + 3^2 + \dots + n^2$ 的和。
   查看练习答案与解析

   答案：通项 i*i，循环累加即可。

2. 矩阵行求和

题目: 编写程序，输入一个有 m 行 n 列的整数矩阵，求矩阵中每行元素（整数）的和，输出结果。

查看答案与解析

参考答案：

#include <stdio.h>

void main()
{
    int m, n, i, j;
    int a[100][100];
    int sum;
    
    printf("请输入矩阵的行数和列数: ");
    scanf("%d %d", &m, &n);
    
    printf("请输入矩阵元素:\n");
    for (i = 0; i < m; i++)
        for (j = 0; j < n; j++)
            scanf("%d", &a[i][j]);
    
    for (i = 0; i < m; i++)
    {
        sum = 0;
        for (j = 0; j < n; j++)
            sum += a[i][j];
        printf("第%d行的和为: %d\n", i + 1, sum);
    }
}

解析： 先读取矩阵的行列数和元素，然后对每一行用内层循环累加该行所有元素，输出每行的和。

---

难度: ⭐⭐ 考点: #二维数组 #嵌套循环

💡 学习锦囊

📖 相关公式与知识点:

• 行求和：固定行号 i，遍历列 j，累加 a[i][j]。
• 列求和：固定列号 j，遍历行 i，累加 a[i][j]。

思路分析

外层循环控制行，内层循环遍历该行的每一列进行累加。

🔄 举一反三

1. 如何求矩阵每列元素的和？
   查看练习答案与解析

   答案：交换内外层循环，外层遍历列 j，内层遍历行 i。

3. 数字之积

题目: 编写程序，求一个正整数各个位上的数字之积。例如：若输入 252，则输出 20。

查看答案与解析

参考答案：

#include <stdio.h>

void main()
{
    int num, product = 1;
    
    printf("请输入一个正整数: ");
    scanf("%d", &num);
    
    while (num > 0)
    {
        product *= num % 10;
        num /= 10;
    }
    
    printf("各位数字之积为: %d\n", product);
}

示例输入: 252
示例输出: 各位数字之积为: 20

解析：num % 10 取出个位数字，num /= 10 去掉个位。循环直到 num 变为 0。product 初始化为 1（乘法单位元）。

---

难度: ⭐⭐ 考点: #数字拆分 #while循环

💡 学习锦囊

📖 相关公式与知识点:

• 取个位：n % 10
• 去个位：n / 10
• 数字分离的标准模式。

思路分析

循环取个位→乘积累积→去掉个位，直到数为 0。

易错点

• product 初始化为 0 会导致结果始终为 0。

🔄 举一反三

1. 求一个正整数各位数字之和。
   查看练习答案与解析

   答案：将 product *= 改为 sum +=，sum 初始化为 0。

4. 去极值求平均

题目: 编写程序，从键盘输入不少于 10 个任意数据，去掉其中最大的 2 个数和最小的 2 个数，求剩余数据的平均值。

查看答案与解析

参考答案：

#include <stdio.h>

void main()
{
    int n, i, j;
    double a[100], temp, sum = 0, avg;
    
    printf("请输入数据个数 (不少于10): ");
    scanf("%d", &n);
    
    if (n < 10)
    {
        printf("数据个数不少于10!\n");
        return;
    }
    
    printf("请输入%d个数据:\n", n);
    for (i = 0; i < n; i++)
        scanf("%lf", &a[i]);
    
    for (i = 0; i < n - 1; i++)
        for (j = 0; j < n - 1 - i; j++)
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
    
    for (i = 2; i < n - 2; i++)
        sum += a[i];
    
    avg = sum / (n - 4);
    printf("剩余数据的平均值为: %.2f\n", avg);
}

解析： 先排序（冒泡排序），排序后最小的 2 个在 a[0] 和 a[1]，最大的 2 个在 a[n-2] 和 a[n-1]。从 a[2] 到 a[n-3] 求和，除以 n-4 得平均值。

---

难度: ⭐⭐⭐ 考点: #排序 #去极值

💡 学习锦囊

📖 相关公式与知识点:

• 冒泡排序：相邻元素两两比较交换。
• 去极值后平均值 = 剩余元素和 / 剩余元素个数。

思路分析

排序后极值自然在两端，直接跳过即可。

🔄 举一反三

1. 若只去掉 1 个最大值和 1 个最小值，如何修改？
   查看练习答案与解析

   答案：循环从 i=1 到 i<n-2，除以 n-2。

5. 素数求和

题目: 编写一个判断素数的通用过程（函数或子程序）。调用该过程，计算并输出区间 [1050, 1150] 内所有素数的和。

查看答案与解析

参考答案：

#include <stdio.h>
#include <math.h>

int isPrime(int n)
{
    int i;
    if (n <= 1) return 0;
    for (i = 2; i <= sqrt(n); i++)
        if (n % i == 0) return 0;
    return 1;
}

void main()
{
    int i, sum = 0;
    
    for (i = 1050; i <= 1150; i++)
    {
        if (isPrime(i))
        {
            sum += i;
            printf("%d ", i);
        }
    }
    
    printf("\n区间[1050,1150]内所有素数的和为: %d\n", sum);
}

解析： 素数判断：若 n≤1 返回假；从 2 到 √n 检查是否有因子。主函数遍历区间，调用 isPrime 判断并累加。

---

难度: ⭐⭐ 考点: #素数判断 #函数

💡 学习锦囊

📖 相关公式与知识点:

• 素数：大于 1 且只能被 1 和自身整除的数。
• 优化：只需检查到 √n。

思路分析

封装素数判断为函数，主函数只需遍历区间并调用。

易错点

• 忘记处理 n≤1 的情况。
• 循环从 2 开始而非 1。

🔄 举一反三

1. 判断一个数是否为素数，循环条件 i <= n/2 和 i <= sqrt(n) 哪个更优？
   查看练习答案与解析

   答案：sqrt(n) 更优，时间复杂度从 O(n) 降为 O(√n)。

6. 字符串转换

题目: 编写程序，将一个字符串中所有下标为奇数位置上的小写字母转成大写字母（若该位置上不是字母，则不转换）。

查看答案与解析

参考答案：

#include <stdio.h>
#include <string.h>

void main()
{
    char str[100];
    int i, len;
    
    printf("请输入一个字符串: ");
    gets(str);
    
    len = strlen(str);
    
    for (i = 1; i < len; i += 2)
    {
        if (str[i] >= 'a' && str[i] <= 'z')
            str[i] = str[i] - 32;
    }
    
    printf("转换后的字符串: %s\n", str);
}

示例输入: abcdefghij
示例输出: 转换后的字符串: aBcDeFgHiJ

解析： 下标从 0 开始，奇数位置即 i=1,3,5,...。判断是否为小写字母（'a'~'z'），若是则减去 32 转为大写（'a'-'A'=32）。

---

难度: ⭐⭐ 考点: #字符串 #大小写转换

💡 学习锦囊

📖 相关公式与知识点:

• 小写→大写：ch - 32 或 ch - ('a' - 'A')
• 大写→小写：ch + 32
• 判断小写：ch >= 'a' && ch <= 'z'

思路分析

步长为 2 遍历奇数下标，判断并转换小写字母。

易错点

• 下标从 0 开始，奇数位置是 1,3,5...而非 0,2,4...
• 忘记判断是否为字母，对非字母也减 32。

🔄 举一反三

1. 将字符串中所有大写字母转为小写。
   查看练习答案与解析

   答案：判断 ch >= 'A' && ch <= 'Z'，执行 ch += 32。