C语言期末复习笔记

ysu_03142026-07-03 22:41

C语言期末考试知识点复习目录

  • [📑 C语言期末考试试题分类笔记](#📑 C语言期末考试试题分类笔记)
    • [📌 题型考点分布大纲（考前必读）](#📌 题型考点分布大纲（考前必读）)
    • [🧱 第一部分：选择题](#🧱 第一部分：选择题)
      • [📂 第一章：概述](#📂 第一章：概述)
        • [考点 1：C语言程序与函数结构特征](#考点 1：C语言程序与函数结构特征)
        • [考点 2：程序的运行与编译方式](#考点 2：程序的运行与编译方式)
        • [考点 3：main主函数的位置与执行顺序](#考点 3：main主函数的位置与执行顺序)
        • [考点 4：结构化程序设计思想](#考点 4：结构化程序设计思想)
      • [📂 第二章：数据类型、运算符和表达式](#📂 第二章：数据类型、运算符和表达式)
        • [考点 1：C语言代数表达式的转换](#考点 1：C语言代数表达式的转换)
        • [考点 2：短路求值与逻辑/关系运算](#考点 2：短路求值与逻辑/关系运算)
        • [考点 3：数据类型转换与混合运算](#考点 3：数据类型转换与混合运算)
        • [考点 4：要求整型运算数的运算符](#考点 4：要求整型运算数的运算符)
        • [5. 逗号表达式](#5. 逗号表达式)
        • [考点 6：合法与不合法用户标识符](#考点 6：合法与不合法用户标识符)
        • [考点 7：C语言常量的概念与边界](#考点 7：C语言常量的概念与边界)
        • [考点 8：字符区间逻辑边界判定](#考点 8：字符区间逻辑边界判定)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [考点 1：关系边界与逻辑表达](#考点 1：关系边界与逻辑表达)
        • [考点 2：switch-case 语句执行机制与穿透效果](#考点 2：switch-case 语句执行机制与穿透效果)
        • [考点 3：for循环条件、执行次数与逻辑判定](#考点 3：for循环条件、执行次数与逻辑判定)
        • [考点 4：do-while / while 循环控制与逻辑等价](#考点 4：do-while / while 循环控制与逻辑等价)
        • [考点 5：if-else 多分支逻辑值与作用域](#考点 5：if-else 多分支逻辑值与作用域)
        • [考点 6：格式化输入输出与表达式配合](#考点 6：格式化输入输出与表达式配合)
        • [考点 7：流程跳转与其它控制考点](#考点 7：流程跳转与其它控制考点)
      • [📂 第四章：函数](#📂 第四章：函数)
        • [考点 1：函数的嵌套调用与返回值计算](#考点 1：函数的嵌套调用与返回值计算)
        • [考点 2：局部静态变量 `static` 的生命周期](#考点 2：局部静态变量 static 的生命周期)
        • [考点 3：常用数学库函数的表达](#考点 3：常用数学库函数的表达)
        • [考点 4：`return` 语句基本规则](#考点 4：return 语句基本规则)
        • [考点 5：递归函数的调用与执行](#考点 5：递归函数的调用与执行)
        • [考点 6：全局变量与标准库函数规则](#考点 6：全局变量与标准库函数规则)
        • [考点 7：主函数规范与声明形式](#考点 7：主函数规范与声明形式)
        • [考点 8：形参实参内存管理与存储类别](#考点 8：形参实参内存管理与存储类别)
      • [📂 第五章：数组](#📂 第五章：数组)
        • [考点 1：字符串处理函数运行机制](#考点 1：字符串处理函数运行机制)
        • [考点 2：字符数组初始化规范与维数合法性](#考点 2：字符数组初始化规范与维数合法性)
        • [考点 3：数组下标嵌套引用判定](#考点 3：数组下标嵌套引用判定)
        • [4. `scanf` 与 `gets` 混合读取字符串](#4. scanf 与 gets 混合读取字符串)
      • [📂 第六章：指针](#📂 第六章：指针)
        • [考点 1：指针变量自增与地址偏移标识](#考点 1：指针变量自增与地址偏移标识)
        • [考点 2：字符指针操作与字符串赋值](#考点 2：字符指针操作与字符串赋值)
        • [考点 3：多指针变量赋值与函数指针](#考点 3：多指针变量赋值与函数指针)
        • [考点 4：main 函数命令行参数格式](#考点 4：main 函数命令行参数格式)
        • [考点 5：行指针与一维数组指针定义](#考点 5：行指针与一维数组指针定义)
        • [考点 6：指针型函数形参传递与地址含义](#考点 6：指针型函数形参传递与地址含义)
      • [📂 第八章：结构体与共用体](#📂 第八章：结构体与共用体)
        • [考点 1：`typedef struct` 别名定义及用法](#考点 1：typedef struct 别名定义及用法)
        • [考点 2：结构体变量内存分配规则](#考点 2：结构体变量内存分配规则)
        • [考点 3：链表节点的插入语句操作](#考点 3：链表节点的插入语句操作)
    • [✏️ 第二部分：填空题（全属第五章内容）](#✏️ 第二部分：填空题（全属第五章内容）)
      • [1️⃣ 题目位置：第37-38页 (题1)](#1️⃣ 题目位置：第37-38页 (题1))
      • [2️⃣ 题目位置：第39-40页 (题2)](#2️⃣ 题目位置：第39-40页 (题2))
      • [3️⃣ 题目位置：第40-41页 (题3)](#3️⃣ 题目位置：第40-41页 (题3))
      • [4️⃣ 题目位置：第42页 (题4)](#4️⃣ 题目位置：第42页 (题4))
      • [5️⃣ 题目位置：第43-44页 (题5)](#5️⃣ 题目位置：第43-44页 (题5))
      • [6️⃣ 题目位置：第44-45页 (题6)](#6️⃣ 题目位置：第44-45页 (题6))
      • [7️⃣ 题目位置：第46页 (题7)](#7️⃣ 题目位置：第46页 (题7))
      • [8️⃣ 题目位置：第47-48页 (题8)](#8️⃣ 题目位置：第47-48页 (题8))
      • [9️⃣ 题目位置：第49页 (题9)](#9️⃣ 题目位置：第49页 (题9))
      • [🔟 题目位置：第50-51页 (题10)](#🔟 题目位置：第50-51页 (题10))
      • [1️⃣1️⃣ 题目位置：第51-52页 (题11)](#1️⃣1️⃣ 题目位置：第51-52页 (题11))
    • [🛠️ 第三部分：改错题（全属第六章内容）](#🛠️ 第三部分：改错题（全属第六章内容）)
      • [1️⃣ 题目位置：第53页 (题1)](#1️⃣ 题目位置：第53页 (题1))
      • [2️⃣ 题目位置：第54-55页 (题2)](#2️⃣ 题目位置：第54-55页 (题2))
      • [3️⃣ 题目位置：第55-56页 (题3)](#3️⃣ 题目位置：第55-56页 (题3))
      • [4️⃣ 题目位置：第57页 (题4)](#4️⃣ 题目位置：第57页 (题4))
      • [5️⃣ 题目位置：第58页 (题5)](#5️⃣ 题目位置：第58页 (题5))
      • [6️⃣ 题目位置：第59-60页 (题6)](#6️⃣ 题目位置：第59-60页 (题6))
      • [7️⃣ 题目位置：第60-61页 (题7)](#7️⃣ 题目位置：第60-61页 (题7))
    • [💻 第四部分：程序设计题](#💻 第四部分：程序设计题)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [1. 同时被5与11整除自然数之和的平方根 (第61-62页)](#1. 同时被5与11整除自然数之和的平方根 (第61-62页))
        • [2. 阶乘组合公式计算 P 的值 (第62-63页)](#2. 阶乘组合公式计算 P 的值 (第62-63页))
        • [3. 迭代法求方程 cos ⁡ ( x ) − x = 0 \cos(x)-x=0 cos(x)−x=0 的实根 (第63-64页)](#3. 迭代法求方程 cos ⁡ ( x ) − x = 0 \cos(x)-x=0 cos(x)−x=0 的实根 (第63-64页))
        • [4. 判断无符号整数是否为回文数 (第64-65页)](#4. 判断无符号整数是否为回文数 (第64-65页))
        • [5. 分数级数多项式求和 (第65-66页)](#5. 分数级数多项式求和 (第65-66页))
        • [6. 两位数拆解与交错合并 (第66-67页)](#6. 两位数拆解与交错合并 (第66-67页))
        • [7. 浮点数四舍五入保留两位小数 (第67-68页)](#7. 浮点数四舍五入保留两位小数 (第67-68页))
        • [8. 对数级数累加求平方根 (第68-69页)](#8. 对数级数累加求平方根 (第68-69页))
      • [📂 第八章：结构体与共用体部分](#📂 第八章：结构体与共用体部分)
        • [1. 结构体单链表遍历求平均分 (第69-71页)](#1. 结构体单链表遍历求平均分 (第69-71页))
        • [2. 筛选高于等于平均分的学生记录 (第71-72页)](#2. 筛选高于等于平均分的学生记录 (第71-72页))
        • [3. 提取指定分数范围内的学生记录 (第72-74页)](#3. 提取指定分数范围内的学生记录 (第72-74页))
        • [4. 计算单个学生多门课程的平均分 (第74-75页)](#4. 计算单个学生多门课程的平均分 (第74-75页))
        • [5. 检索成绩最低的学生记录 (第75-76页)](#5. 检索成绩最低的学生记录 (第75-76页))
        • [6. 找出并保存所有最低分的学生记录 (第77-78页)](#6. 找出并保存所有最低分的学生记录 (第77-78页))
        • [7. 过滤低于平均分的学生记录 (第78-79页)](#7. 过滤低于平均分的学生记录 (第78-79页))
        • [8. 找出分数最高的学生记录人数 (第79-80页)](#8. 找出分数最高的学生记录人数 (第79-80页))
        • [9. 按分数由高到低对学生记录排序 (第80-82页)](#9. 按分数由高到低对学生记录排序 (第80-82页))
        • [10. 返回最高成绩的学生人数并保存记录 (第82-83页)](#10. 返回最高成绩的学生人数并保存记录 (第82-83页))
  • [📑 C语言期末考试·新增题库分类笔记](#📑 C语言期末考试·新增题库分类笔记)
    • [📌 新增选择题考点分布](#📌 新增选择题考点分布)
      • [📂 第一章：概述与基本概念](#📂 第一章：概述与基本概念)
        • [考点 1：注释、分号与程序基本单位判定](#考点 1：注释、分号与程序基本单位判定)
        • [考点 2：C程序的编译、执行与机器指令转换](#考点 2：C程序的编译、执行与机器指令转换)
        • [考点 3：C程序构成与 `main` 函数位置](#考点 3：C程序构成与 main 函数位置)
      • [📂 第二章：数据类型、运算符和表达式](#📂 第二章：数据类型、运算符和表达式)
        • [考点 1：合法与非法用户标识符判定](#考点 1：合法与非法用户标识符判定)
        • [考点 2：常量与转义字符、字符串深度辨析](#考点 2：常量与转义字符、字符串深度辨析)
        • [考点 3：运算符优先级与结合性](#考点 3：运算符优先级与结合性)
        • [考点 4：混合类型转换、除法与逻辑真假](#考点 4：混合类型转换、除法与逻辑真假)
        • [考点 5：高级位运算与特殊赋值计算](#考点 5：高级位运算与特殊赋值计算)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [考点 1：格式化输出修饰符 `%m.nf` 精度与宽度判定](#考点 1：格式化输出修饰符 %m.nf 精度与宽度判定)
        • [考点 2：条件、循环与逻辑边界判定](#考点 2：条件、循环与逻辑边界判定)
      • [📂 第四章：函数与局部/全局变量](#📂 第四章：函数与局部/全局变量)
        • [考点 1：形参实参占用单元规范](#考点 1：形参实参占用单元规范)
        • [考点 2：递归函数调用次数深度剖析](#考点 2：递归函数调用次数深度剖析)
        • [考点 3：变量隐含存储类型与生存期](#考点 3：变量隐含存储类型与生存期)
        • [考点 4：标准库函数的重定义约束](#考点 4：标准库函数的重定义约束)
      • [📂 第五章：数组](#📂 第五章：数组)
        • [考点 1：一维数组定义界限规范](#考点 1：一维数组定义界限规范)
      • [📂 第六章：指针](#📂 第六章：指针)
        • [考点 1：指针变量代表地址的选项组合判定](#考点 1：指针变量代表地址的选项组合判定)
        • [考点 2：不能表示数组元素的表达式判定](#考点 2：不能表示数组元素的表达式判定)
        • [考点 3：指针数组与行指针的混淆辨析](#考点 3：指针数组与行指针的混淆辨析)
      • [📂 第七章：预编译指令](#📂 第七章：预编译指令)
        • [考点 1：宏替换的本质](#考点 1：宏替换的本质)
        • [考点 2：`#include` 尖括号 `<>` 与双引号 `""` 的检索路径区别](#include尖括号<>与双引号""` 的检索路径区别)
        • [考点 3：带参数的宏展开嵌套求值](#考点 3：带参数的宏展开嵌套求值)
      • [📂 第八章：结构体与共用体、文件操作大类](#📂 第八章：结构体与共用体、文件操作大类)
        • [考点 1：共用体 `union` 内存分配特征](#考点 1：共用体 union 内存分配特征)
        • [考点 2：结构体生存期与内存驻留](#考点 2：结构体生存期与内存驻留)
        • [考点 3：文件操作常用库函数](#考点 3：文件操作常用库函数)
    • [📝 新增上机操作题源码（填空与改错）](#📝 新增上机操作题源码（填空与改错）)
      • [1️⃣ 降序数组合并算法](#1️⃣ 降序数组合并算法)
      • [2️⃣ 提取二维数组中每列最大元素的平均值](#2️⃣ 提取二维数组中每列最大元素的平均值)
      • [3️⃣ 字符串处理：在串首插入指定字符](#3️⃣ 字符串处理：在串首插入指定字符)
      • [4️⃣ 右下拐角与左上拐角方阵生成](#4️⃣ 右下拐角与左上拐角方阵生成)
      • [5️⃣ 统计并输出一个正整数各位数码中 0 的个数](#5️⃣ 统计并输出一个正整数各位数码中 0 的个数)
      • [6️⃣ 字符串边界清除：删除字符串中间的 `*` 号](#6️⃣ 字符串边界清除：删除字符串中间的 * 号)
      • [7️⃣ 二维矩阵按顺时针/逆时针方向旋转90度](#7️⃣ 二维矩阵按顺时针/逆时针方向旋转90度)

📑 C语言期末考试试题分类笔记

📌 题型考点分布大纲（考前必读）

根据考试大纲要求，各题型考查章节有着严格的划分：

  • 填空题 ：只出 第五章（数组） 内容。
  • 改错题 ：只出 第六章（指针） 内容。
  • 程序设计题 ：只出 第三章（算法和控制语句） 与 第八章（结构体与共用体） 内容。

🧱 第一部分：选择题

📂 第一章：概述

考点 1：C语言程序与函数结构特征
  • 题目位置：第1页第1题 / 第2页第7题
    以下叙述中错误的是（ B / A ）
    A. 一个C语言程序只能有一个主函数
    B. C语言编写的每个函数都可以进行独立的编译并执行
    C. C语言编写的函数都可以作为一个独立的源程序文件
    D. C语言编写的函数源程序, 其文件名后缀可以是C
  • 题目位置：第1页第4题
    一个C语言程序是由（ C ）
    A. 若干过程组成
    B. 若干子程序组成
    C. 函数组成
    D. 一个主程序和若干子程序组成
  • 题目位置：第2页第9题
    以下叙述正确的是（ D ）
    A. C语言程序是由过程和函数组成的
    B. C语言函数不可以单独编译
    C. C语言中除了main函数, 其他函数不可作为单独文件形式存在
    D. C语言函数可以嵌套调用, 例如: fun(fun(x))
考点 2：程序的运行与编译方式
  • 题目位置：第1页第2题
    计算机高级语言程序的运行方法有编译执行和解释执行两种, 以下叙述中正确的是（ A ）
    A. C语言程序仅可以编译执行
    B. C语言程序仅可以解释执行
    C. 以上说法都不对
    D. C语言程序既可以编译执行又可以解释执行
  • 题目位置：第1页第6题
    以下叙述正确的是（ C ）
    A. 在C程序中, main函数必须位于程序的最前面
    B. 在对一个C程序进行编译的过程中, 可发现注释中的拼写错误
    C. C语言本身没有输入输出语句
    D. 程序的每行中只能写一条语句
  • 题目位置：第2页第8题
    以下叙述正确的是（ B ）
    A. C程序的书写格式是固定的, 每行只能写一条语句
    B. C程序中注释部分可以单独占一行
    C. 构成C程序的基本单位是函数, 所有函数名都可以由用户命名
    D. 在对C语言程序进行编译时, 可以发现注释行中的拼写错误
考点 3：main主函数的位置与执行顺序
  • 题目位置：第1页第3题
    C语言规定: 在一个源程序中, main的位置（ A ）
    A. 可以任意
    B. 必须在最后
    C. 必须在最开始
    D. 必须在系统调用的库函数后面
  • 题目位置：第2页第10题
    一个C程序的执行是从（ D ）
    A. 本程序文件的第一个函数开始, 到本程序main函数结束
    B. 本程序文件的第一个函数开始, 到本程序文件的最后一个函数结束
    C. 本程序的main函数开始, 到本程序文件的最后一个函数结束
    D. 本程序的main函数开始, 到main函数结束
  • 题目位置：第2页第11题
    以下叙述不正确的是（ A ）
    A. 在C程序中, 注释说明只能位于一条语句的后面
    B. C程序的基本组成单位是函数
    C. 一个C源程序可由一个或多个函数组成
    D. 一个C源程序必须包含一个main函数
考点 4：结构化程序设计思想
  • 题目位置：第1页第5题
    以下关于结构化程序设计的叙述中正确的是（ B ）
    A. 一个结构化程序必须同时由顺序、分支、循环三种结构组成
    B. 在C语言中, 程序的模块化是利用函数实现的
    C. 由三种基本结构构成的程序只能解决小规模的问题
    D. 结构化程序使用goto 语句会很便捷

📂 第二章：数据类型、运算符和表达式

考点 1：C语言代数表达式的转换
  • 题目位置：第2页第1题
    若有数学式 3 a e b c \frac{3ae}{bc} bc3ae，则不正确的C语言表达式是（ A ）
    A. 3*a*e/b*c
    B. a/b/c*e*3
    C. 3*a*e/b/c
    D. a*e/c/b*3
考点 2：短路求值与逻辑/关系运算
  • 题目位置：第2页第2题
    设: int a=1, b=2, c=3, d=4, m=2, n=2; 执行 (m=a>b) && (n=c>d) 后n的值为（ C ）。
    A. 4
    B. 3
    C. 2
    D. 1
  • 题目位置：第2页第3题
    下列表达式中, 不满足"当x的值为偶数时值为真, 为奇数时值为假"的要求的是（ C ）
    A. (x/2*2-x)==0
    B. !(x%2)
    C. !(x%2 != 0)
    D. x%2==0
  • 题目位置：第3页第8题
    若是数值类型, 则逻辑表达式 (a==1)||(a!=1) 的值是（ D ）
    A. 不知道a的值, 不能确定
    B. 0
    C. 2
    D. 1
  • 题目位置：第4页第19题
    若有定义语句: int k1=10, k2=20; , 执行表达式 (k1=k1>k2) && (k2=k2>k1) 后, k1和k2的值分别为（ B ）
    A. 0和1
    B. 0和20
    C. 10和1
    D. 10和20
  • 题目位置：第5页第20题
    以下选项中, 能表示逻辑值"假"的是（ B ）
    A. 0.000001
    B. 0
    C. 100.0
    D. 1
考点 3：数据类型转换与混合运算
  • 题目位置：第3页第4题
    表达式 18/4*sqrt(4.0)/8 值的数据类型为（ B ）。
    A. char
    B. double
    C. 不确定
    D. float
  • 题目位置：第4页第14题
    设变量a是整型, f是实型, i是双精度型, 则表达式 10+'a'+i*f 值的数据类型为（ C ）
    A. float
    B. 不确定
    C. double
    D. int
  • 题目位置：第4页第15题
    在C语言中, char型数据在内存中的存储形式是（ C ）。
    A. 补码
    B. 原码
    C. ASCII码
    D. 反码
考点 4：要求整型运算数的运算符
  • 题目位置：第3页第5题
    在C语言中, 要求运算数必须是整型的运算符是（ A ）
    A. %
    B. /
    C. ++
    D. !=
5. 逗号表达式
  • 题目位置：第3页第6题
    若x, i, j和k都是int型变量, 则计算表达式 x=(i=4,j=16,k=32) 后, x的值为（ B ）。
    A. 4
    B. 32
    C. 16
    D. 52
  • 题目位置：第4页第12题
    假设所有变量均为整型, 则表达式 (a=2, b=5, b++, a+b) 的值是（ B ）。
    A. 7
    B. 8
    C. 6
    D. 2
考点 6：合法与不合法用户标识符
  • 题目位置：第3页第7题
    C语言中的标识符只能由字母、数字和下划线三种字符组成, 且第一个字符（ D ）
    A. 必须为下划线
    B. 必须为字母
    C. 可以是字母、数字和下划线中的任意一种
    D. 必须为字母或下划线
  • 题目位置：第3页第10题
    下面四个选项中, 均是合法的用户标识符的选项是（ A ）。
    A. _123 temp INT
    B. A P_0 do
    C. b-a goto int
    D. float lao _A
  • 题目位置：第4页第16题
    下面四个选项中, 均是不合法的用户标识符的选项是（ B ）。
    A. float lao _A
    B. b-a goto int
    C. _123 temp INT
    D. A P_0 do
考点 7：C语言常量的概念与边界
  • 题目位置：第4页第13题
    下面正确的字符常量是（ B ）
    A. "\"
    B. 'w'
    C. ""
    D. 'c"'
  • 题目位置：第4页第17题
    以下选项中关于C语言常量的叙述错误的是: （ D ）
    A. 所谓常量, 是指在程序运行过程中, 其值不能被改变的量
    B. 常量分为整型常量、实型常量、字符常量和字符串常量
    C. 常量可分为数值型常量和非数值型常量
    D. 经常被使用的变量可定义成常量
  • 题目位置：第5页第21题
    以下选项中非法的字符常量是（ B ）
    A. '\102'
    B. '\019'
    C. '\xff'
考点 8：字符区间逻辑边界判定
  • 题目位置：第3页第9题
    判断字符型变量c1是否为数字字符的正确表达式为（ A ）
    A. (c1>='0') && (c1<='9')
    B. (c1>=0) && (c1<=9)
    C. ('0'>=c1) || ('9'<=c1)
    D. '0'<=c1<='9'
  • 题目位置：第3页第11题
    以下关于C语言数据类型使用的叙述中错误的是（ B ）
    A. 若要处理如"人员工资"的相关数据, 应使用单精度类型
    B. 若只处理"真"和"假"两种逻辑值, 应使用逻辑类型
    C. 若要保存带有多位小数的数据, 应使用双精度类型
    D. 若要准确无误差的表示自然数, 应使用整数类型
  • 题目位置：第4页第18题
    判断字符型变量c1是否为小写字母的正确表达式为（ B ）。
    A. ('a'>=c1) || ('z'<=c1)
    B. (c1>='a') && (c1<='z')
    C. (c1>=a) && (c1<=z)
    D. 'a'<=c1<='z'

📂 第三章：算法和控制语句部分

考点 1：关系边界与逻辑表达
  • 题目位置：第5页第1题
    为表示关系 x ≥ y ≥ z x \ge y \ge z x≥y≥z, 应使用的表达式是（ A ）
    A. (x>=y) && (y>=z)
    B. (x>=y>=z)
    C. (x>=y) AND (y>=z)
    D. (x>=y) & (y>=z)
  • 题目位置：第9页第14题
    以下程序段中, 与语句: k=a>b? (b>c?1:0):0; 功能相同的是（ A ）
    A. if ((a>b) && (b>c)) k=1; else k=0;
    B. if ((a>b) || (b>c)) k=1; else k=0;
    C. if (a>b) k=1; else if (b>c) k=1; else k=0;
    D. if (a<=b) k=0; else if (b<=c) k=1;
  • 题目位置：第9页第15题 / 第13页第34题
    为了避免在嵌套的条件语句 if-else 中产生二义性, C语言规定: else子句总是与（ B / C ）配对。
    A. 其之后最近的if
    B. 其之前最近的未配对的if
    C. 缩排位置相同的if
    D. 同一行上的if
  • 题目位置：第21页第67题
    判断char型变量c是否为大写字母的C的表达式是（ C ）
    A. 'A'<=c<='Z'
    B. ('A'<=c) AND ('Z'>=c)
    C. (c>='A') && (c<='Z')
    D. (c>='A') & (c<='Z')
考点 2：switch-case 语句执行机制与穿透效果

  • 题目位置：第5页第2题
    有以下程序：

    c 复制代码 
    main()
{ int i;
  for(i=0; i<3; i++)
     switch(i)
     { case 1: printf("%d", i);
       case 2: printf("%d", i);
       default: printf("%d", i);
     }
}

    执行后输出结果是（ A ）
    A. 011122
    B. 120
    C. 012020
    D. 012

  • 题目位置：第7页第9题 / 第20页第65题

    c 复制代码 
    main()
{ int x=1, a=0, b=0;
  switch (x)
  { case 0: b++;
    case 1: a++;
    case 2: a++; b++; 
  }
  printf("a=%d, b=%d", a, b);
}

    该程序的输出结果是（ B ）
    A. 2, 2
    B. 2, 1
    C. 1, 1
    D. 1, 0

  • 题目位置：第12页第31题
    C语言中, switch后的括号内表达式的值可以是（ C ）
    A. 只能为整型和字符型
    B. 只能为整型
    C. 任何类型
    D. 只能为整型, 字符型, 枚举型

  • 题目位置：第15页第44题 / 第21页第68题
    下列程序的输出结果是（ A ）。

    c 复制代码 
    main()
{ int x=1, y=0, a=0, b=0;
  switch(x)
  { case 1: switch(y)
            { case 0: a++; break;
              case 1: b++; break;
            }
    case 2: a++; b++; break;
    case 3: a++; b++; break;
  }
  printf("a=%d, b=%d\n", a, b);
}

    A. a=2, b=1
    B. a=2, b=2
    C. a=1, b=0
    D. a=1, b=1

  • 题目位置：第18页第57题
    若有定义语句 int a, b; double x; 则下列选项中没有错误的是（ B ）
    A. switch((int)(x)%2) { case 0.0: a++; break; ... }
    B. switch((int)x%2) { case 0: a++; break; case 1: b++; break; default: a++; b++; }
    C. switch(x%2) { ... }
    D. switch((int)x%2.0) { ... }

考点 3：for循环条件、执行次数与逻辑判定

  • 题目位置：第5页第3题
    对 for(表达式1;;表达式3) 可理解为（ A ）。
    A. for(表达式1; 1; 表达式3)
    B. for(表达式1; 0; 表达式3)
    C. for(表达式1; 表达式1; 表达式3)
    D. for(表达式1; 表达式3; 表达式3)

  • 题目位置：第5页第4题
    若i为整型变量, 则以下循环执行次数是（ A ）。
    for (i=2; i=0; ) printf("%d", i);
    A. 0次
    B. 1次
    C. 无限次
    D. 2次

  • 题目位置：第6页第7题
    执行语句 for(i=1; i++<4; ); 后变量i的值是（ D ）。
    A. 不定
    B. 3
    C. 4
    D. 5

  • 题目位置：第8页第13题
    以下程序的输出结果是（ A ）

    c 复制代码 
    main()
{ int x, i;
  for(i=1; i<=100; i++)
  { x=i;
    if (++x % 2 == 0)
       if(x % 3 == 0)
          if(++x % 7 == 0)
             printf("%d ", x);
  }
  printf("\n");
}

    A. 28 70
    B. 39 81
    C. 42 84
    D. 26 68

  • 题目位置：第9页第17题
    以下程序段的输出结果是（ B ）

    c 复制代码 
    int k, j, s;
for(k=2; k<6; k++, k++)
{ s=1;
  for(j=k; j<6; j++) s+=j;
}
printf("%d\n", s);

    A. 15
    B. 10
    C. 24
    D. 9

  • 题目位置：第11页第27题
    以下程序段的输出结果为（ A ）。
    for(i=4; i>1; i--) for(j=1; j<i; j++) putchar('#');
    A. ######
    B. 无
    C. #
    D. ###

  • 题目位置：第12页第30题
    若x是int类型变量, 以下程序段的输出结果是（ D ）

    c 复制代码 
    for(x=3; x<6; x++)
   printf((x%2)? ("**%d"): ("##%d\n"), x);

    A. ##3 **4 ##5
    B. ##3 **4##5
    C. **3 ##4 **5
    D. **3##4 (换行) **5

  • 题目位置：第13页第32题
    设j和k都是int类型, 则下面的for循环语句（ C ）。
    for (j=0, k=0; j<=9 && k!=876; j++) scanf("%d", &k);
    A. 最多执行9次
    B. 循环体一次也不执行
    C. 最多执行10次
    D. 是无限循环

  • 题目位置：第15页第43题
    以下for循环的执行次数是（ A ）。
    for (x=0, y=0; (y==123) && (x<4); x++);
    A. 4次
    B. 是无限循环
    C. 3次
    D. 循环次数不定

  • 题目位置：第17页第53题
    以下程序段的输出结果是（ C ）

    c 复制代码 
    int i, j, m=0;
for(i=1; i<=15; i+=4)
   for(j=3; j<=19; j+=4) m++;
printf("%d\n", m);

    A. 15
    B. 12
    C. 20
    D. 25

  • 题目位置：第24页第83题
    以下程序段中的变量已正确定义：
    for (i=0; i<4; i++, i++) for (k=1; k<3; k++) printf("*"); 程序段的输出结果是（ B ） (注: 原题干答案标记C有误，实际外层循环执行2次，内层2次，共4次)
    A. ****
    B. **
    C. ********
    D. *

  • 题目位置：第26页第91题
    若i和k都是int类型变量, 有以下for语句：
    for (i=0, k=-1; k=1; k++) printf("*****\n");
    下面关于语句执行情况的叙述中正确的是（ A ）
    A. 构成无限循环
    B. 循环体一次也不执行
    C. 循环体执行两次
    D. 循环体执行一次

考点 4：do-while / while 循环控制与逻辑等价

  • 题目位置：第6页第5题
    有以下程序段：

    c 复制代码 
    int n=0, p;
do {
    scanf("%d", &p); n++;
} while (p!=12345 && n<3);

    此处do-while循环的结束条件是（ D ）。
    A. p的值等于12345并且n的值大于等于3
    B. p的值不等于12345并且n的值小于3
    C. p的值不等于12345或者n的值小于3
    D. p的值等于12345或者n的值大于等于3

  • 题目位置：第6页第6题 / 第20页第62题
    以下描述中正确的是（ D / C ）。
    A. do-while 循环中, 根据情况可以省略 while
    B. 由于 do-while 循环中循环体语句只能是一条可执行语句, 所以循环体内不能使用复合语句
    C. do-while 循环由do开始, 用while结束, 在while(表达式)后面不能写分号
    D. 在do-while循环体中, 一定要有能使 while 后面表达式的值变为零("假")的操作

  • 题目位置：第9页第16题
    t为int类型, 进入下面的循环之前, t的值为0：
    while(t=1) { ... } 则以下叙述中正确的是（ B ）。
    A. 以上说法都不对
    B. 循环控制表达式的值为1
    C. 循环控制表达式的值为0
    D. 循环控制表达式不合法

  • 题目位置：第9页第18题
    语句 while(!E); 中的表达式 !E 等价于（ B ）。
    A. E!=1
    B. E==0
    C. E==1
    D. E!=0

  • 题目位置：第10页第19题
    以下程序段的输出结果是（ B ）

    c 复制代码 
    int x=3;
do {
    printf("%3d", x-=2);
} while (!(-x));

    A. 死循环
    B. 1 -2
    C. 3 0
    D. 1

  • 题目位置：第10页第20题
    以下程序的运行结果是（ B ）。

    c 复制代码 
    main()
{ int i=1, sum=0;
  while (i<10) sum = sum+1; i++;
  printf("i=%d, sum=%d", i, sum);
}

    A. i=10, sum=9
    B. 运行出现错误 (死循环)
    C. i=2, sum=1
    D. i=9, sum=9

  • 题目位置：第10页第22题
    以下程序中, while循环的循环次数是（ A ）

    c 复制代码 
    main()
{ int i=0;
  while(i<10)
  { if(i<1) continue;
    if(i==5) break;
    i++;
  }
}

    A. 死循环, 不能确定次数
    B. 6
    C. 4
    D. 1

  • 题目位置：第13页第38题
    以下程序的执行结果是（ C ）

    c 复制代码 
    main()
{ int x=0, s=0;
  while(!x!=0) s+=++x;
  printf("%d ",s); }

    A. 无限循环
    B. 0
    C. 1
    D. 语法错误

  • 题目位置：第16页第46题
    以下程序的运行结果是（ B ）。 (注: 原答案标D有误，实际%后漏了数，按正常卷意应为B)

    c 复制代码 
    main()
{ int n;
  for (n=1; n<=10; n++)
  { if (n%3==0) continue;
    printf("%d", n);
  }
}

    A. 12
    B. 12457810
    C. 1234567890
    D. 369

  • 题目位置：第16页第47题
    C语言中 while 和 do-while 循环的主要区别是（ B ）。
    A. while的循环控制条件比 do-while的循环控制条件更严格
    B. do-while 的循环体至少无条件执行一次
    C. do-while 的循环体不能是复合语句
    D. do-while 允许从外部转到循环体内

  • 题目位置：第16页第48题
    以下不是无限循环的语句为（ C ）。
    A. for( ; ; x+=1);
    B. while (1) {x++;}
    C. for(y=0, x=1; x>++y; x=i++) i=x;
    D. for(i=10; ; i--) sum+=i;

  • 题目位置：第17页第50题
    下列程序的输出为（ C ）。

    c 复制代码 
    main()
{ int y=10;
  while (y--);
  printf("y=%d\n", y);
}

    A. while构成无限循环
    B. y=0
    C. y=-1
    D. y=1

  • 题目位置：第17页第51题
    有以下程序, 程序运行后的输出结果是（ D ）

    c 复制代码 
    int main()
{ int a=1, b=2;
  while (a<6) { b+=a; a+=2; b%=10; }
  printf("%d,%d\n", a, b);
  return 0;
}

    A. 5, 11
    B. 6, 1
    C. 7, 11
    D. 7, 1

  • 题目位置：第17页第52题
    在以下给出的表达式中, 与 do while(E) 语句中的(E)不等价的表达式是（ A ）。
    A. (E==0)
    B. (E>0 || E<0)
    C. (!E==0)
    D. (E!=0)

  • 题目位置：第18页第55题
    以下程序的执行结果是（ A ）。

    c 复制代码 
    main()
{ int num=0;
  while(num<=2) { num++; printf("%d, ", num); } }

    A. 1, 2, 3,
    B. 1, 2, 3, 4,
    C. 1, 2,
    D. 0, 1, 2

  • 题目位置：第18页第56题
    下面程序的运行结果是（ A ）

    c 复制代码 
    #include <stdio.h>
main ()
{ int y=10;
  do y--; while(--y);
  printf ("%d\n", y);
}

    A. 0
    B. 1
    C. 8
    D. -1

  • 题目位置：第19页第61题
    while (fabs(t) < 1e-5) if (!s/10) break; 循环结束的条件是（ C ）。
    A. fabs(t)<1e-5 && !s/10
    B. fabs(t)<1e-5
    C. t>=1e-5 || t<=-1e-5 || s>-10 && s<10
    D. s/10==0

  • 题目位置：第22页第71题
    在C语言中, 为了结束由while语句构成的循环, while后一对圆括号中表达式的值应该为（ B ）。
    A. 1
    B. 0
    C. True
    D. 非0

  • 题目位置：第23页第76题
    若变量已正确定义, 有以下程序段：
    i=0; do printf("%d, ", i); while(i++); printf("%d\n", i); 其输出结果是（ D ）
    A. 0, 0
    B. 程序进入无限循环
    C. 1, 1
    D. 0, 1

  • 题目位置：第24页第84题
    有以下程序段, 以下叙述中正确的是（ B ）

    c 复制代码 
    int main()
{ while (getchar() !='\n'); }

    A. 此while语句将无限循环
    B. 当执行此while语句时, 只有按回车键程序才能继续执行
    C. 当执行此while语句时, 按任意键程序就能继续执行
    D. getchar() 不可以出现在 while语句的条件表达式中

  • 题目位置：第25页第85题
    有以下程序: 程序运行后的输出结果是（ A ）

    c 复制代码 
    int main()
{ int a=7;
  while (a--);
  printf("%d\n", a);
  return 0;
}

    A. -1
    B. 1
    C. 0
    D. 7

考点 5：if-else 多分支逻辑值与作用域

  • 题目位置：第6页第8题

    c 复制代码 
    main()
{ int a=5, b=4, c=3, d=2;
  if (a>b>c) printf("%d\n", d);
  else if ((c-1>=d)==1) printf("%d\n", d+1);
  else printf("%d\n", d+2);
}

    执行后输出结果是（ D ）
    A. 2
    B. 4
    C. 编译时出错
    D. 3

  • 题目位置：第7页第11题
    运行以下程序后, 输出的结果是（ A ）

    c 复制代码 
    main()
{ int k=-3;
  if (k<=0) printf("****\n");
  else printf("&&&&\n");
}

    A. ****
    B. 有语法错误不能通过编译
    C. &&&&
    D. ****&&&&

  • 题目位置：第8页第12题
    下面的程序片断所表示的数学函数关系是（ A ）

    c 复制代码 
    y=-1;
if (x!=0) { if(x>0) y=1; } else y=0;

    A. y = { − 1 ( x < 0 ) 0 ( x = = 0 ) 1 ( x > 0 ) y = \begin{cases} -1 & (x<0) \\ 0 & (x==0) \\ 1 & (x>0) \end{cases} y=⎩ ⎨ ⎧−101(x<0)(x==0)(x>0)
    B. y = { 1 ( x < 0 ) − 1 ( x = = 0 ) 0 ( x > 0 ) y = \begin{cases} 1 & (x<0) \\ -1 & (x==0) \\ 0 & (x>0) \end{cases} y=⎩ ⎨ ⎧1−10(x<0)(x==0)(x>0)

  • 题目位置：第10页第21题
    设有定义: int a=1, b=2, c=3; 以下语句中执行效果与其它三个不同的是（ D ）
    A. if (a>b) {c=a; a=b; b=c;}
    B. if (a>b) c=a, a=b, b=c;
    C. if (a>b) {c=a; a=b; b=c;}
    D. if (a>b) c=a; a=b; b=c;

  • 题目位置：第11页第23题
    选择结构中的条件与循环结构中循环成立的条件值只能被判断为"真"或"假"。哪个数作为逻辑"假"值（ D ）。
    A. -1
    B. 非零的数
    C. 1
    D. 0

  • 题目位置：第11页第24题
    int a=1, b=2, c=3; if (a>b) a=b; if (a>c) a=c; 则a的值为（ A ）。
    A. 1
    B. 不一定
    C. 3
    D. 2

  • 题目位置：第12页第28题

    c 复制代码 
    main ()
{ float x=2.0, y;
  if (x<0.0) y=0.0;
  else if (x<10.0) y=1.0/x;
  else y=1.0;
  printf ("%f\n", y); }

    该程序的输出结果是（ A ）
    A. 0.500000
    B. 0.250000
    C. 1.000000
    D. 0.000000

  • 题目位置：第13页第33题
    int a=3, b=2, c=1; if(a>b>c) a=b; else a=c; 则a的值为（ C ）。
    A. 2
    B. 3
    C. 1
    D. 0

  • 题目位置：第13页第35题
    以下不正确的if语句形式是（ D ）。
    A. if (x<y) {x++; y++;}
    B. if (x>y && x!=y);
    C. if (x==y) x+=y;
    D. if (x!=y) scanf("%d", &x) else scanf("%d", &y);

  • 题目位置：第14页第39题
    int a=1, b=2, c=3; if(a>c) b=a; a=c; c=b; 则c的值为（ B ）。
    A. 3
    B. 2
    C. 不一定
    D. 1

  • 题目位置：第14页第41题
    假定所有变量均已正确定义, 下列程序段运行后x的值是（ D ）。
    k1=1; k2=2; k3=3; x=15;
    if(!k1) x--; else if (k2) x=4; else x=3;
    A. 15
    B. 14
    C. 3
    D. 4

  • 题目位置：第14页第42题

    c 复制代码 
    int main()
{ int i, j, m=1;
  for(i=1; i<3; i++)
  { for(j=3; j>0; j--)
       if (i*j>3) break;
    m*=i*j;
  }
  printf("m=%d\n", m); return 0;
}

    输出结果是（ B ）
    A. m=2
    B. m=6
    C. m=4
    D. m=5

  • 题目位置：第21页第70题
    假定所有变量均已正确定义, 下面语句段执行后的x的值是（ B ）
    a=b=c=0; x=35;
    if(!a) x--; else if (b) if (c) x=3; else x=4; (注: 原答案标B有误，实际应为34)
    A. 34
    B. 4
    C. 35
    D. 3

  • 题目位置：第22页第73题 / 第23页第78题
    有以下程序, 程序运行后的输出结果是（ B / C ）

    c 复制代码 
    int main()
{ int a=1, b=0; // 题78中为 x=1, y=0
  if(!a) b++;
  else if (a==0) if (a) b+=2; else b+=3;
  printf("%d\n", b); return 0;
}

    A. 3
    B. 0
    C. 1
    D. 2

  • 题目位置：第23页第77题
    下列条件语句中输出结果与其他语句不同的是（ C ）
    A. if (a) printf("%d\n",x); else printf("%d\n", y);
    B. if (a==0) printf("%d\n", y); else printf("%d\n",x);
    C. if (a=-0) printf("%d\n",x); else printf("%d\n",y);
    D. if (a!=0) printf("%d\n",x); else printf("%d\n",y);

考点 6：格式化输入输出与表达式配合

  • 题目位置：第11页第25题
    有以下程序, 若想使变量m中的值为123, n中的值为456, p中的值为789, 则正确的输入是（ B ）

    c 复制代码 
    scanf("m=%dn=%dp=%d", &m, &n, &p);

    A. m=123 n=456 p=789
    B. m=123n=456p=789
    C. 123 456 789
    D. m=123, n=456, p=789

  • 题目位置：第15页第45题
    有以下程序, 当从第1列开始输入数据（<CR>代表回车）：12<CR>34<CR> 则输出结果是（ C ）

    c 复制代码 
    scanf ("%c%c", &a, &b); c=getchar(); d=getchar();
printf("%c%c%c%c\n", a, b, c, d);

    A. 12 (换行) 34
    B. 1234
    C. 12 (换行) 3
    D. 12

  • 题目位置：第23页第74题
    有输入语句: scanf("a=%d, b=%d, c=%d", &a, &b, &c); 为使a的值为1, b为3, c为2, 正确的输入是（ B ）。
    A. a=1 b=3 c=2
    B. a=1, b=3, c=2
    C. 1 3 2
    D. 1, 3, 2

  • 题目位置：第23页第75题
    程序段: int x=12; double y=3.141593; printf("%d%8.6f",x,y); 的输出结果是（ C ）
    A. 12, 3.141593
    B. 12 3.141593
    C. 123.141593
    D. 123.1415930

  • 题目位置：第24页第79题
    有以下程序段执行从键盘输入: name=Lili num=1001<回车> 后, name的值是（ C ）

    c 复制代码 
    char name [20]; int num;
scanf ("name=%s num=%d", name, &num);

    A. Lili num-
    B. name=Lili
    C. Lili
    D. name=Lili num=1001

  • 题目位置：第24页第80题
    执行下列程序片段时输出的结果是（ C ）。
    int x=13, y=5; printf("%d", x%=(y/=2));
    A. 2
    B. 3
    C. 1
    D. 0

  • 题目位置：第24页第81题
    要求a1, a2, c1, c2的值分别为10, 20, A和B, 正确的数据输入方式是（ A ）。
    scanf("%d%c%d%c", &a1, &c1, &a2, &c2);
    A. 10A20B
    B. 10A20 B
    C. 10 A20B
    D. 10 A 20 B

  • 题目位置：第24页第82题
    若定义x为double型变量, 则能正确输入x值的语句是（ C ）。
    A. scanf ("%5.1f", &x);
    B. scanf ("%f", x);
    C. scanf("%lf", &x);
    D. scanf("%f", &x);

考点 7：流程跳转与其它控制考点

  • 题目位置：第12页第29题
    判断两个字符串是否相等, 正确的表达方式是（ D ）
    A. while (s1=s2)
    B. while (s1==s2)
    C. while (strcmp(s1, s2)=0)
    D. while (strcmp(s1, s2) == 0)

  • 题目位置：第13页第36题
    结构化程序设计所规定的三种基本控制结构是（ D ）。
    A. 树形、网形、环形
    B. 输入、处理、输出
    C. 主程序、子程序、函数
    D. 顺序、选择、循环

  • 题目位置：第16页第49题
    从循环体内某一层跳出, 继续执行循环外的语句是（ A ）
    A. break语句
    B. return语句
    C. continue语句
    D. 空语句

  • 题目位置：第19页第60题
    在下述程序中, 判断 i>j 共执行了多少次（ C ）

    c 复制代码 
    for(;;) { i+=k; if(i > j) { printf("%d\n", s); break; } s+=i; }

    (注: 初始化为 i=0, j=10, k=2)
    A. 4
    B. 8
    C. 6
    D. 7

📂 第四章：函数

考点 1：函数的嵌套调用与返回值计算

  • 题目位置：第26页第1题
    有以下程序, 程序运行后的输出结果是（ B ）

    c 复制代码 
    int fun (int x, int y) { if (x!=y) return ((x+y)/2); else return (x); }
// main中调用: printf("%d\n", fun (2*a, fun (b,c))); 设 a=4, b=5, c=6

    A. 12
    B. 6
    C. 3
    D. 8

  • 题目位置：第27页第2题
    有以下程序, 程序运行的输出结果（ A ）

    c 复制代码 
    int f(int x) { return x*2; }
// main中调用: m=f(f(f(n))); 设 n=1

    A. 8
    B. 4
    C. 1
    D. 2

  • 题目位置：第27页第3题
    程序执行后变量w中的值是（ C ）

    c 复制代码 
    int fun1 (double a) { return a*=a; }
int fun2 (double x, double y) { ... return (int)(a+b); }
// main中调用: w=fun2 (1.1, 2.0);

    A. 5.21
    B. 0.0
    C. 5.0
    D. 5

  • 题目位置：第28页第5题
    有以下程序, 程序运行后的输出结果是（ D ）

    c 复制代码 
    int f(int x, int y) { return ((y-x)*x); }
// main中调用: d=f(f(a,b), f(a,c)); 设 a=3, b=4, c=5

    A. 10
    B. 8
    C. 7
    D. 9

  • 题目位置：第28页第6题
    有以下程序: 程序运行后的输出结果是（ B ）

    c 复制代码 
    void fun(int p) { int d=2; p=d++; printf("%d", p); }
// main中调用: fun(a); printf("%d\n", a); 设 a=1

    A. 22
    B. 21
    C. 12
    D. 32

考点 2：局部静态变量 static 的生命周期

  • 题目位置：第27页第4题
    有以下程序, 程序运行后的输出结果是（ B ）

    c 复制代码 
    int fun() { static int x=1; x*=2; return x; }
// main中调用: for (i=1; i<=3; i++) s*=fun(); 设 s=1 初始

    A. 10
    B. 64
    C. 0
    D. 30

  • 题目位置：第29页第7题
    有以下程序: 程序运行后的输出结果是（ A ）

    c 复制代码 
    int fun() { static int x=1; x+=1; return x; }
// main中调用: for (i=1; i<=5; i++) s+=fun(); 设 s=1 初始

    A. 21
    B. 6
    C. 120
    D. 11

考点 3：常用数学库函数的表达
  • 题目位置：第29页第8题
    若有代数式 ∣ n x + e x ∣ \sqrt{|n^x + e^x|} ∣nx+ex∣ , 则能够正确表示该代数式的C语言表达式是（ A ） (注: 依据库函数pow与exp标准规则)
    A. sqrt (fabs (pow (n, x) +exp (x)))
    B. sqrt (fbs (pow (n, x) +pow (x, e)))
考点 4：return 语句基本规则
  • 题目位置：第29页第9题
    以下关于return语句叙述中正确的是（ D ）
    A. 定义void类型的函数中可以有带返回值的return语句
    B. 没有return语句的自定义函数在执行结束时不能返回到调用处
    C. 一个自定义函数中必须有一条return语句
    D. 一个自定义函数中可以根据不同情况设置多条 return 语句
考点 5：递归函数的调用与执行

  • 题目位置：第29页第10题
    设有如下函数定义, 若执行调用语句: n=fun(3); , 则函数fun总共被调用的次数是（ B ）

    c 复制代码 
    int fun(int k) { if (k<1) return 0; else if(k==1) return 1; else return fun(k-1)+1; }

    A. 2
    B. 3
    C. 5
    D. 4

考点 6：全局变量与标准库函数规则
  • 题目位置：第30页第11题
    在一个C语言源程序文件中所定义的全局变量, 其作用域为（ C ）
    A. 所在函数的全部范围
    B. 所在文件的全部范围
    C. 由具体定义位置和extern说明来决定范围
    D. 所在程序的全部范围
  • 题目位置：第30页第14题
    以下说法不正确的是（ C ）
    A. 系统不允许用户重新定义标准库函数
    B. 标准库函数按分类在不同的头文件中声明
    C. 用户可以重新定义标准库函数
    D. 用户若需要调用标准库函数, 调用前必须使用预编译命令
考点 7：主函数规范与声明形式
  • 题目位置：第30页第13题
    以下程序的主函数中调用了在其前面定义的fun函数, 则以下选项中错误的fun函数首部是（ B ）
    double a [15], k; k=fun (a);
    A. double fun (double *a)
    B. double fun (double a)
    C. double fun (double a[])
    D. double fun (double a [15])
  • 题目位置：第30页第15题
    下列叙述中正确的是（ A ）
    A. C语言规定必须用main作为主函数名, 程序将从此开始执行, 在此结束
    B. main可作为用户标识符, 用以命名任意一个函数作为主函数
    C. 可以在程序中由用户指定任意一个函数作为主函数
    D. C语言程序将从源程序中第一个函数开始执行
考点 8：形参实参内存管理与存储类别
  • 题目位置：第30页第16题
    若函数调用时的实参为变量时, 以下关于函数形参和实参的叙述中正确的是（ B ）
    A. 同名的实参和形参占同一存储单元
    B. 函数的形参和实参分别占用不同的存储单元
    C. 函数的实参和其对应的形参共占同一存储单元
    D. 形参只是形式上的存在, 不占用具体存储单元
  • 题目位置：第30页第17题
    在C语言中, 只有在使用时才占用内存单元的变量, 其存储类型是（ B ）。
    A. extern和register
    B. auto和register
    C. static和register
    D. auto 和 static
  • 题目位置：第31页第18题
    设函数中有整形变量, 为保证其在未赋初值的情况下初值为0, 应该选择的存储类别是（ D ）
    A. register
    B. auto
    C. auto 或register
    D. static

📂 第五章：数组

考点 1：字符串处理函数运行机制

  • 题目位置：第31页第1题
    有以下程序, 程序运行后的输出结果是（ B ）

    c 复制代码 
    char a[20]="ABCD\0EFG\0", b[]="IJK";
strcat (a, b); printf("%s\n", a);

    A. ABCDE\0FG\0IJK
    B. ABCDIJK
    C. EFGIJK
    D. IJK

  • 题目位置：第31页第2题
    有以下程序, 程序运行后的输出结果是（ D ）

    c 复制代码 
    char s[]="012xy\08s34f4w2";
for (i=0; s[i]!=0; i++) if (s[i]>='0' && s[i]<='9') n++;

    A. 7
    B. 0
    C. 8
    D. 3

  • 题目位置：第32页第3题
    下列选项中, 能够满足"若字符串s1等于字符串s2, 则执行ST"要求的是（ A ）
    A. if (strcmp(s2, s1) == 0) ST;
    B. if (s1-s2==0) ST;
    C. if (strcpy(s1, s2)==1) ST;
    D. if (s1==s2) ST;

  • 题目位置：第33页第10题
    有以下程序, 程序运行后的输出结果是（ C ）

    c 复制代码 
    char x[]="STRING"; x[0]=0; x[1]='\0'; x[2]='0';
printf("%d %d\n", sizeof(x), strlen(x));

    A. 7 0
    B. 6 1
    C. 7 1
    D. 6 3

考点 2：字符数组初始化规范与维数合法性
  • 题目位置：第32页第4题
    以下选项中正确的语句组是（ D ）
    A. char *s; s={"BOOK!"};
    B. char s[]; s="BOOK!";
    C. char s[10]; s="BOOK!";
    D. char s[] = "BOOK!";
  • 题目位置：第32页第5题
    以下数组定义中错误的是（ A ）
    A. int x[2][3]={``{1,2}, {3,4}, {5,6}};
    B. int x[2][3]={1,2,3,4,5,6};
    C. int x[][3]={0};
    D. int x[][3]={``{1,2,3}, {4,5,6}};
  • 题目位置：第32页第7题
    下列选项中, 能正确定义数组的语句是（ D ）
    A. int num; int num[N];
    B. int N=2008; int num[N];
    C. int num [0..2008];
    D. #define N 2008 (下一行) int num[N];
  • 题目位置：第33页第11题
    若要定义一个具有5个元素的整型数组, 以下错误的定义语句是（ C ）
    A. int a[5] ={0};
    B. int b[]={0,0,0,0,0};
    C. int i=5, d[i];
    D. int c[2+3];
考点 3：数组下标嵌套引用判定
  • 题目位置：第32页第6题
    若有定义语句: int m[]={5,4,3,2,1}, i=4; 则下面对数组元素的引用中错误的是（ A ）
    A. m[m[0]]
    B. m[2*2]
    C. m[m[i]]
    D. m[m[i]]
4. scanf 与 gets 混合读取字符串

  • 题目位置：第32页第8题
    程序运行若输入: how are you? I am fine<回车> 则输出结果是（ C ）

    c 复制代码 
    scanf("%s", a); gets (b); printf("%s\n %s\n", a, b);

    A. how are you? (换行) I am fine
    B. how are you? I am fine
    C. how (换行) are you? I am fine
    D. how are you?

  • 题目位置：第33页第9题
    下面是有关C语言字符数组的描述, 其中错误的是（ C ）
    A. 不可以用赋值语句给字符数组名赋字符串
    B. 可以用输入语句把字符串整体输入给字符数组
    C. 字符数组中的内容不一定是字符串
    D. 字符数组只能存放字符串

📂 第六章：指针

考点 1：指针变量自增与地址偏移标识
  • 题目位置：第34页第1题
    若已定义 char s[10]; 则在下面表达式中不表示 s[1] 的地址是（ D ）。
    A. &s[1]
    B. &s[0]+1
    C. s+1
    D. s++
  • 题目位置：第35页第9题
    下面程序段的运行结果是（ C ）。
    char *s="abcde"; s+=2; printf("%s", s);
    A. 字符'c'的地址
    B. 不确定
    C. cde
    D. 字符'c'
考点 2：字符指针操作与字符串赋值

  • 题目位置：第34页第2题
    下面程序段的运行结果是（ D ）。

    c 复制代码 
    char a[]="language", *p; p=a;
while (*p!='u') { printf("%c", *p-32); p++; }

    A. language
    B. langUAGE
    C. LANGUAGE
    D. LANG

  • 题目位置：第34页第3题
    下面能正确进行字符串赋值操作的是（ C ）
    A. char s[5]={'A', 'B', 'C', 'D', 'E'};
    B. char s[5]={"ABCDE"};
    C. char *ss = "ABCDE";
    D. char *s; scanf("%s", s);

  • 题目位置：第35页第10题
    下面判断正确的是（ D ）。
    A. char str[10]={"china"}; 等价于 char str[10]; str[]={"china"};
    B. char c[4]="abc", d[4]="abc"; 等价于 char c[4]=d[4]="abc";
    C. char *a="china"; 等价于 char *a; *a="china";
    D. char *s="china"; 等价于 char *s; s="china";

考点 3：多指针变量赋值与函数指针
  • 题目位置：第34页第4题
    设p1和p2是指向同一个字符串的指针变量, 为字符变量, 则以下能正确执行并得到有意义的结果的赋值语句是（ C ）。
    A. p2=c
    B. c=*p1+*p2;
    C. p1=p2;
    D. c=*p1*(*p2);
  • 题目位置：第35页第5题
    已有函数 max(a,b) , 为了让函数指针变量p指向函数max, 正确的赋值方法是（ C ）。
    A. *p=max(a,b);
    B. *p=max;
    C. p=max;
    D. p=max(a,b);
  • 题目位置：第36页第13题
    若有说明: int *p, m=5, n; 以下程序段正确的是（ A ）
    A. p=&n; *p = m;
    B. p=&n; scanf("%d", &p);
    C. p=&n; scanf("%d", *p);
    D. scanf("%d", &n); *p=n;
  • 题目位置：第36页第15题
    已有定义 int k=2; int *ptr1, *ptr2; 且ptr1和ptr2均已指向变量k, 下面不能正确执行的赋值语句是（ A ）
    A. ptr2=k;
    B. k=*ptr1+*ptr2;
    C. k=*ptr1*(*ptr2);
    D. ptr1=ptr2;
考点 4：main 函数命令行参数格式
  • 题目位置：第35页第6题
    以下正确的叙述是（ B ）。
    A. C语言允许main函数带形参, 且形参个数和形参名均可由用户指定
    B. 当main函数带有形参时, 传给形参的值只能从命令行中得到
    C. 若有说明: int main(int argc, char **argv) , 则argc的值必须大于1
    D. C语言允许 main函数带形参, 形参名只能是argc 和 argv
考点 5：行指针与一维数组指针定义
  • 题目位置：第35页第7题
    若有定义: int(*p)[4]; 则标识符p（ D ）。
    A. 是一个指针数组名
    B. 定义不合法
    C. 是一个指向整型变量的指针
    D. 是一个指针, 它指向一个含有四个整型元素的一维数组
  • 题目位置：第35页第8题 / 第35页第11题
    设有程序段: char s[]="china"; char *p=s; 则下面叙述正确的是（ A / B ）。
    A. *p 与 s[0] 相等
    B. 数组中的内容和指针变量p中的内容相等
    C. s数组长度和p所指向的字符串长度相等
    D. s和p完全相同
考点 6：指针型函数形参传递与地址含义

  • 题目位置：第35页第12题
    已有变量定义和函数调用语句: int a=25; print_value(&a); 下面函数的输出结果是（ D ）

    c 复制代码 
    void print_value (int *x) { printf("%d\n", ++*x); }

    A. 24
    B. 23
    C. 25
    D. 26

  • 题目位置：第36页第14题
    变量的指针, 其含义是指该变量的（ B ）
    A. 值
    B. 地址
    C. 一个标志
    D. 名

📂 第八章：结构体与共用体

考点 1：typedef struct 别名定义及用法

  • 题目位置：第36页
    若有以下语句，以下叙述中正确的是（ A ）

    c 复制代码 
    typedef struct S { int g; char h; } T;

    A. 可用T定义结构体变量
    B. T是struct S类型的变量
    C. 可用S定义结构体变量
    D. S是 struct 类型的变量

考点 2：结构体变量内存分配规则
  • 题目位置：第36题
    当定义一个结构体变量时, 系统分配给它的内存是（ D ）。
    A. 结构体中最后一个成员所需内存量
    B. 成员中占内存量最大的容量
    C. 结构体中第一个成员所需内存量
    D. 各成员所需内存量的总和
考点 3：链表节点的插入语句操作
  • 题目位置：第37页
    根据 struct link { int data; struct link *next; } a, b, c, *p, *q; 节点a和b已有链表结构。若指针p指向a, 指针q指向c, 则能把c插入到a和b之间形成新链表的语句是（ C ）
    A. p->next=&c; q->next=p->next;
    B. p.next=q; q.next=p.next;
    C. p->next=q; q->next=&b;
    D. a.next=c; c.next=b;

✏️ 第二部分：填空题（全属第五章内容）

1️⃣ 题目位置：第37-38页 (题1)

  • 考点：一维浮点型数组的累加与算术平均值及四舍五入。
  • 填空源码填补 ：
    【空1】 sum+=x[i]; 或 sum=sum+x[i];
    【空2】 avg*1000; 或 1000*avg;
    【空3】 (avg+5)/10; 或 (5+avg)/10;

2️⃣ 题目位置：第39-40页 (题2)

  • 考点：数位筛选（整除、偶数条件组合判定）与逆序下标递减。
  • 填空源码填补 ：
    【空1】 i=1
    // 核心判定填补
    【空2】 k%i==0 && i%2==0
    【空3】 j-1 或 --j

3️⃣ 题目位置：第40-41页 (题3)

  • 考点：上题完整循环表达式形式复写考查。
  • 填空源码填补 ：
    【空1】 i=1; i<=k; i++
    【空2】 if (k%i==0 && i%2==0)
    【空3】 i=j-1; i>=0; i--

4️⃣ 题目位置：第42页 (题4)

  • 考点：遍历匹配特定字符强制退出截断。
  • 填空源码填补 ：
    【空1】 break;
    【空2】 i++ 或 ++i

5️⃣ 题目位置：第43-44页 (题5)

  • 考点：整型数逐位拆解并强转为字符存入字符数组。
  • 填空源码填补 ：
    【空1】 n>0 或 0<n
    【空2】 n%10+'0' 或 n%10+48
    【空3】 str[i]='\0'; 或 str[i]=0;

6️⃣ 题目位置：第44-45页 (题6)

  • 考点 ：字符串特定项删除并手动设置串结束符 \0。
  • 填空源码填补 ：
    【空1】 break;
    【空2】 i++;
    【空3】 '\0' 或 0

7️⃣ 题目位置：第46页 (题7)

  • 考点：单维字符数组原地逆置算法。
  • 填空源码填补 ：
    【空1】 n-- 或 --n
    【空2】 s[i]=s[n]
    【空3】 s[n]=t

8️⃣ 题目位置：第47-48页 (题8)

  • 考点：自定义函数形参设置与截断标记。
  • 填空源码填补 ：
    【空1】 void fun (char s[], int n) 或 void fun (char *s, int n)
    【空2】 j=0
    【空3】 s[j]='\0'; 或 s[j]=0;

9️⃣ 题目位置：第49页 (题9)

  • 考点：二维数组行维元素求和前的清零与累加器操作。
  • 填空源码填补 ：
    【空1】 bb[i]=0;
    【空2】 bb[i]+=score[i][j];

🔟 题目位置：第50-51页 (题10)

  • 考点：同第49页的多维表格累加求和算法填补。
  • 填空源码填补 ：
    【空1】 bb[i]=0;
    【空2】 bb[i]+=score[i][j];

1️⃣1️⃣ 题目位置：第51-52页 (题11)

  • 考点：二维矩阵网格四条外边界线坐标范围的逻辑匹配。
  • 填空源码填补 ：
    【空1】 i==0 || i==n-1 || j==0 || j==n-1
    【空2】 bb[i][j]=0

🛠️ 第三部分：改错题（全属第六章内容）

1️⃣ 题目位置：第53页 (题1)

  • 考点：逆序存放时的正确计算公式偏移与结束符字符常量的混淆纠正。
  • 源码修正 ：
    【错误代码1】 t[i]=s[sl-1]; → \rightarrow → 修正为 t[i]=s[sl-1-i];
    【错误代码2】 t[2*s1]="\0"; → \rightarrow → 修正为 t[2*s1]='\0'; 或 t[2*s1]=0;

2️⃣ 题目位置：第54-55页 (题2)

  • 考点：函数缺省返回值的补全、指针偏移量运算的次序颠倒、以及循环判定反向。
  • 源码修正 ：
    【错误代码1】 fun (char *p) → \rightarrow → 修正为 void fun (char *p)
    【错误代码2】 p=q+i; → \rightarrow → 修正为 q=p+i;
    【错误代码3】 while(q<p) → \rightarrow → 修正为 while(q>p)

3️⃣ 题目位置：第55-56页 (题3)

  • 考点：野指针直接解引用赋值错误，应该传递基地址。
  • 源码修正 ：
    【错误代码1】 *r=t; → \rightarrow → 修正为 r=t;
    【错误代码2】 【1】: → \rightarrow → 修正为 r=t; 或 r=&t[0]; （重置子循环指针）

4️⃣ 题目位置：第57页 (题4)

  • 考点：数组累加运算符号错误以及形参解引用赋值符号错误。
  • 源码修正 ：
    【错误代码1】 t=s[k]; → \rightarrow → 修正为 t+=s[k];
    【错误代码2】 *aver=&ave; → \rightarrow → 修正为 *aver=ave;

5️⃣ 题目位置：第58页 (题5)

  • 考点：经典指针参数接收地址修饰符以及指针解引用的两两调换。
  • 源码修正 ：
    【错误代码1】 void fun(int a, b) → \rightarrow → 修正为 void fun(int *a, int *b)
    【错误代码2】 t=b; b=a; a=t; → \rightarrow → 修正为 t=*a; *a=*b; *b=t;

6️⃣ 题目位置：第59-60页 (题6)

  • 考点：临时过渡交换单元的变量类型错误以及大小判断逻辑条件逆转。
  • 源码修正 ：
    【错误代码1】 float *k; → \rightarrow → 修正为 float k;
    【错误代码2】 if(*a>*c) → \rightarrow → 修正为 if(*a<*c)

7️⃣ 题目位置：第60-61页 (题7)

  • 考点：选择排序法中核心索引记录符号漏写分号及变量混淆。
  • 源码修正 ：
    【错误代码1】 {p=j → \rightarrow → 修正为 p=j;
    【错误代码2】 p=j; → \rightarrow → 修正为 p=i;

💻 第四部分：程序设计题

📂 第三章：算法和控制语句部分

1. 同时被5与11整除自然数之和的平方根 (第61-62页)
c 复制代码 
double fun(int n)
{
    double s = 0.0;
    int i;
    for(i = 0; i < n; i++)
    {
        if(i % 5 == 0 && i % 11 == 0)
        {
            s = s + i;
        }
    }
    s = sqrt(s); /* 对s求平方根 */
    return s;
}
2. 阶乘组合公式计算 P 的值 (第62-63页)
c 复制代码 
float fun (int m, int n)
{
    int i;
    double p = 1.0;
    for (i = 1; i <= m; i++)
        p = p * i; /* 求m! */
    for (i = 1; i <= n; i++)
        p = p / i; /* 求m!/n! */
    for (i = 1; i <= m - n; i++)
        p = p / i; /* 求m!/(n!*(m-n)!) */
    return p;
}
3. 迭代法求方程 cos ⁡ ( x ) − x = 0 \cos(x)-x=0 cos(x)−x=0 的实根 (第63-64页)
c 复制代码 
float fun()
{
    float x1 = 0.0, x0;
    do
    {
        x0 = x1;
        x1 = cos(x0);
    } 
    while (fabs(x0 - x1) >= 1e-6);
    return x1;
}
4. 判断无符号整数是否为回文数 (第64-65页)
c 复制代码 
int fun(int n)
{
    int m, t = 0;
    m = n;
    while (m != 0)
    {
        t = t * 10 + m % 10;
        m = m / 10;
    }
    if (t == n)
        return 1;
    else
        return 0;
}
5. 分数级数多项式求和 (第65-66页)
c 复制代码 
float fun (int n)
{
    int i, s1 = 0; /* 定义整型变量s1, 表示分母 */
    float s = 0.0;  /* 定义单精度变量s, 表示每一项 */
    for (i = 1; i <= n; i++) 
    {
        s1 = s1 + i;   /* 求每一项的分母 */
        s = s + 1.0 / s1; /* 求多项式的值 */
    }
    return s;
}
6. 两位数拆解与交错合并 (第66-67页)
c 复制代码 
long fun(int a, int b)
{
    return (a % 10) * 1000 + (b % 10) * 10 + (a / 10) * 10 + b / 10;
}
7. 浮点数四舍五入保留两位小数 (第67-68页)
c 复制代码 
float fun (float h)
{
    long t;
    t = (h * 1000 + 5) / 10;
    return (float)t / 100;
}
8. 对数级数累加求平方根 (第68-69页)
c 复制代码 
double fun(int m)
{
    int i;
    double s = 0.0;
    for(i = 1; i <= m; i++)
        s = s + log(i);
    return sqrt(s);
}

📂 第八章：结构体与共用体部分

1. 结构体单链表遍历求平均分 (第69-71页)
c 复制代码 
double fun (STREC *h)
{
    double av = 0.0;
    STREC *p = h->next; /* p直接指向"头节点"的下一个节点, 即第一个成绩 */
    while (p != NULL)
    {
        av = av + p->s; /* 求总分数 */
        p = p->next;
    }
    return av / N; /* 返回平均值 */
}
2. 筛选高于等于平均分的学生记录 (第71-72页)
c 复制代码 
double fun (STREC *a, STREC *b, int *n)
{
    int i;
    double av = 0.0;
    *n = 0;
    for (i = 0; i < N; i++)
        av = av + a[i].s;
    av = av / N; /* 求平均值 */
    for (i = 0; i < N; i++)
        if (av <= a[i].s)
        {
            b[*n] = a[i]; 
            *n = *n + 1;
        } /* 将高于等于平均分的学生存入b所指存储单元中, 并统计人数 */
    return av; /* 返回平均分 */
}
3. 提取指定分数范围内的学生记录 (第72-74页)
c 复制代码 
int fun (STREC *a, STREC *b, int l, int h)
{
    int i, j = 0;
    for (i = 0; i < N; i++)
        if (a[i].s >= l && a[i].s <= h)
            /* 将分数高于l, 低于h的学生记录存于结构体数组b中 */
            b[j++] = a[i];
    return j; /* 返回分数范围内的学生人数 */
}
4. 计算单个学生多门课程的平均分 (第74-75页)
c 复制代码 
void fun (STREC *p)
{
    int i;
    p->ave = 0.0;
    for (i = 0; i < N; i++)
        p->ave = p->ave + p->s[i]; /* 求各门成绩的总和 */
    p->ave = p->ave / N; /* 求平均分 */
}
5. 检索成绩最低的学生记录 (第75-76页)
c 复制代码 
void fun (STU a[], STU *s)
{
    int i;
    *s = a[0]; /* 先认为第1个值最小 */
    for (i = 0; i < N; i++) /* 如果在循环的过程中, 发现比第1个值更小的则赋给*s */
        if (s->s > a[i].s)
            *s = a[i];
}
6. 找出并保存所有最低分的学生记录 (第77-78页)
c 复制代码 
int fun (STREC *a, STREC *b)
{
    int i, j = 0, n = 0, min;
    min = a[0].s;
    for (i = 0; i < N; i++)
        if (a[i].s < min)
            min = a[i].s;
    for (i = 0; i < N; i++)
        if (a[i].s == min)
        {
            *(b + j) = a[i]; 
            j++; 
            n++;
        }
    return n;
}
7. 过滤低于平均分的学生记录 (第78-79页)
c 复制代码 
double fun (STREC *a, STREC *b, int *n)
{
    int i, j = 0;
    double av = 0.0;
    for (i = 0; i < N; i++)
        av = av + a[i].s;
    av = av / N; /* 求平均值 */
    for(i = 0; i < N; i++)
        if (a[i].s < av) 
            b[j++] = a[i]; /* 将低于平均值的学生记录存入结构体b中 */
    *n = j; /* 指针传回低于平均值的学生人数 */
    return av; /* 返回平均值 */
}
8. 找出分数最高的学生记录人数 (第79-80页)
c 复制代码 
int fun (STREC *a, STREC *b)
{
    int i, j = 0, max;
    max = a[0].s;
    for (i = 0; i < N; i++)
        if (a[i].s > max)
            max = a[i].s;
    for (i = 0; i < N; i++)
        if (a[i].s == max)
        {
            b[j++] = a[i];
        }
    return j;
}
9. 按分数由高到低对学生记录排序 (第80-82页)
c 复制代码 
void fun (STREC a[])
{
    int i, j;
    STREC t;
    for(i = 1; i < N; i++)
        for(j = 0; j < N - 1; j++)
            if (a[j].s < a[j+1].s)
            {
                t = a[j]; 
                a[j] = a[j+1]; 
                a[j+1] = t;
            }
}
10. 返回最高成绩的学生人数并保存记录 (第82-83页)
c 复制代码 
int fun (STREC *a, STREC *b)
{
    int i, j = 0, max = a[0].s;
    for(i = 0; i < N; i++)
        if (max < a[i].s)
            max = a[i].s; /* 找出最大值 */
    for(i = 0; i < N; i++)
        if (max == a[i].s) 
            b[j++] = a[i]; /* 找出成绩与max相等的学生的记录, 存入结构体b中 */
    return j; /* 返回最高成绩的学生人数 */
}

C语言期末考试·新增题库分类笔记目录

  • [📑 C语言期末考试试题分类笔记](#📑 C语言期末考试试题分类笔记)
    • [📌 题型考点分布大纲（考前必读）](#📌 题型考点分布大纲（考前必读）)
    • [🧱 第一部分：选择题](#🧱 第一部分：选择题)
      • [📂 第一章：概述](#📂 第一章：概述)
        • [考点 1：C语言程序与函数结构特征](#考点 1：C语言程序与函数结构特征)
        • [考点 2：程序的运行与编译方式](#考点 2：程序的运行与编译方式)
        • [考点 3：main主函数的位置与执行顺序](#考点 3：main主函数的位置与执行顺序)
        • [考点 4：结构化程序设计思想](#考点 4：结构化程序设计思想)
      • [📂 第二章：数据类型、运算符和表达式](#📂 第二章：数据类型、运算符和表达式)
        • [考点 1：C语言代数表达式的转换](#考点 1：C语言代数表达式的转换)
        • [考点 2：短路求值与逻辑/关系运算](#考点 2：短路求值与逻辑/关系运算)
        • [考点 3：数据类型转换与混合运算](#考点 3：数据类型转换与混合运算)
        • [考点 4：要求整型运算数的运算符](#考点 4：要求整型运算数的运算符)
        • [5. 逗号表达式](#5. 逗号表达式)
        • [考点 6：合法与不合法用户标识符](#考点 6：合法与不合法用户标识符)
        • [考点 7：C语言常量的概念与边界](#考点 7：C语言常量的概念与边界)
        • [考点 8：字符区间逻辑边界判定](#考点 8：字符区间逻辑边界判定)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [考点 1：关系边界与逻辑表达](#考点 1：关系边界与逻辑表达)
        • [考点 2：switch-case 语句执行机制与穿透效果](#考点 2：switch-case 语句执行机制与穿透效果)
        • [考点 3：for循环条件、执行次数与逻辑判定](#考点 3：for循环条件、执行次数与逻辑判定)
        • [考点 4：do-while / while 循环控制与逻辑等价](#考点 4：do-while / while 循环控制与逻辑等价)
        • [考点 5：if-else 多分支逻辑值与作用域](#考点 5：if-else 多分支逻辑值与作用域)
        • [考点 6：格式化输入输出与表达式配合](#考点 6：格式化输入输出与表达式配合)
        • [考点 7：流程跳转与其它控制考点](#考点 7：流程跳转与其它控制考点)
      • [📂 第四章：函数](#📂 第四章：函数)
        • [考点 1：函数的嵌套调用与返回值计算](#考点 1：函数的嵌套调用与返回值计算)
        • [考点 2：局部静态变量 `static` 的生命周期](#考点 2：局部静态变量 static 的生命周期)
        • [考点 3：常用数学库函数的表达](#考点 3：常用数学库函数的表达)
        • [考点 4：`return` 语句基本规则](#考点 4：return 语句基本规则)
        • [考点 5：递归函数的调用与执行](#考点 5：递归函数的调用与执行)
        • [考点 6：全局变量与标准库函数规则](#考点 6：全局变量与标准库函数规则)
        • [考点 7：主函数规范与声明形式](#考点 7：主函数规范与声明形式)
        • [考点 8：形参实参内存管理与存储类别](#考点 8：形参实参内存管理与存储类别)
      • [📂 第五章：数组](#📂 第五章：数组)
        • [考点 1：字符串处理函数运行机制](#考点 1：字符串处理函数运行机制)
        • [考点 2：字符数组初始化规范与维数合法性](#考点 2：字符数组初始化规范与维数合法性)
        • [考点 3：数组下标嵌套引用判定](#考点 3：数组下标嵌套引用判定)
        • [4. `scanf` 与 `gets` 混合读取字符串](#4. scanf 与 gets 混合读取字符串)
      • [📂 第六章：指针](#📂 第六章：指针)
        • [考点 1：指针变量自增与地址偏移标识](#考点 1：指针变量自增与地址偏移标识)
        • [考点 2：字符指针操作与字符串赋值](#考点 2：字符指针操作与字符串赋值)
        • [考点 3：多指针变量赋值与函数指针](#考点 3：多指针变量赋值与函数指针)
        • [考点 4：main 函数命令行参数格式](#考点 4：main 函数命令行参数格式)
        • [考点 5：行指针与一维数组指针定义](#考点 5：行指针与一维数组指针定义)
        • [考点 6：指针型函数形参传递与地址含义](#考点 6：指针型函数形参传递与地址含义)
      • [📂 第八章：结构体与共用体](#📂 第八章：结构体与共用体)
        • [考点 1：`typedef struct` 别名定义及用法](#考点 1：typedef struct 别名定义及用法)
        • [考点 2：结构体变量内存分配规则](#考点 2：结构体变量内存分配规则)
        • [考点 3：链表节点的插入语句操作](#考点 3：链表节点的插入语句操作)
    • [✏️ 第二部分：填空题（全属第五章内容）](#✏️ 第二部分：填空题（全属第五章内容）)
      • [1️⃣ 题目位置：第37-38页 (题1)](#1️⃣ 题目位置：第37-38页 (题1))
      • [2️⃣ 题目位置：第39-40页 (题2)](#2️⃣ 题目位置：第39-40页 (题2))
      • [3️⃣ 题目位置：第40-41页 (题3)](#3️⃣ 题目位置：第40-41页 (题3))
      • [4️⃣ 题目位置：第42页 (题4)](#4️⃣ 题目位置：第42页 (题4))
      • [5️⃣ 题目位置：第43-44页 (题5)](#5️⃣ 题目位置：第43-44页 (题5))
      • [6️⃣ 题目位置：第44-45页 (题6)](#6️⃣ 题目位置：第44-45页 (题6))
      • [7️⃣ 题目位置：第46页 (题7)](#7️⃣ 题目位置：第46页 (题7))
      • [8️⃣ 题目位置：第47-48页 (题8)](#8️⃣ 题目位置：第47-48页 (题8))
      • [9️⃣ 题目位置：第49页 (题9)](#9️⃣ 题目位置：第49页 (题9))
      • [🔟 题目位置：第50-51页 (题10)](#🔟 题目位置：第50-51页 (题10))
      • [1️⃣1️⃣ 题目位置：第51-52页 (题11)](#1️⃣1️⃣ 题目位置：第51-52页 (题11))
    • [🛠️ 第三部分：改错题（全属第六章内容）](#🛠️ 第三部分：改错题（全属第六章内容）)
      • [1️⃣ 题目位置：第53页 (题1)](#1️⃣ 题目位置：第53页 (题1))
      • [2️⃣ 题目位置：第54-55页 (题2)](#2️⃣ 题目位置：第54-55页 (题2))
      • [3️⃣ 题目位置：第55-56页 (题3)](#3️⃣ 题目位置：第55-56页 (题3))
      • [4️⃣ 题目位置：第57页 (题4)](#4️⃣ 题目位置：第57页 (题4))
      • [5️⃣ 题目位置：第58页 (题5)](#5️⃣ 题目位置：第58页 (题5))
      • [6️⃣ 题目位置：第59-60页 (题6)](#6️⃣ 题目位置：第59-60页 (题6))
      • [7️⃣ 题目位置：第60-61页 (题7)](#7️⃣ 题目位置：第60-61页 (题7))
    • [💻 第四部分：程序设计题](#💻 第四部分：程序设计题)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [1. 同时被5与11整除自然数之和的平方根 (第61-62页)](#1. 同时被5与11整除自然数之和的平方根 (第61-62页))
        • [2. 阶乘组合公式计算 P 的值 (第62-63页)](#2. 阶乘组合公式计算 P 的值 (第62-63页))
        • [3. 迭代法求方程 cos ⁡ ( x ) − x = 0 \cos(x)-x=0 cos(x)−x=0 的实根 (第63-64页)](#3. 迭代法求方程 cos ⁡ ( x ) − x = 0 \cos(x)-x=0 cos(x)−x=0 的实根 (第63-64页))
        • [4. 判断无符号整数是否为回文数 (第64-65页)](#4. 判断无符号整数是否为回文数 (第64-65页))
        • [5. 分数级数多项式求和 (第65-66页)](#5. 分数级数多项式求和 (第65-66页))
        • [6. 两位数拆解与交错合并 (第66-67页)](#6. 两位数拆解与交错合并 (第66-67页))
        • [7. 浮点数四舍五入保留两位小数 (第67-68页)](#7. 浮点数四舍五入保留两位小数 (第67-68页))
        • [8. 对数级数累加求平方根 (第68-69页)](#8. 对数级数累加求平方根 (第68-69页))
      • [📂 第八章：结构体与共用体部分](#📂 第八章：结构体与共用体部分)
        • [1. 结构体单链表遍历求平均分 (第69-71页)](#1. 结构体单链表遍历求平均分 (第69-71页))
        • [2. 筛选高于等于平均分的学生记录 (第71-72页)](#2. 筛选高于等于平均分的学生记录 (第71-72页))
        • [3. 提取指定分数范围内的学生记录 (第72-74页)](#3. 提取指定分数范围内的学生记录 (第72-74页))
        • [4. 计算单个学生多门课程的平均分 (第74-75页)](#4. 计算单个学生多门课程的平均分 (第74-75页))
        • [5. 检索成绩最低的学生记录 (第75-76页)](#5. 检索成绩最低的学生记录 (第75-76页))
        • [6. 找出并保存所有最低分的学生记录 (第77-78页)](#6. 找出并保存所有最低分的学生记录 (第77-78页))
        • [7. 过滤低于平均分的学生记录 (第78-79页)](#7. 过滤低于平均分的学生记录 (第78-79页))
        • [8. 找出分数最高的学生记录人数 (第79-80页)](#8. 找出分数最高的学生记录人数 (第79-80页))
        • [9. 按分数由高到低对学生记录排序 (第80-82页)](#9. 按分数由高到低对学生记录排序 (第80-82页))
        • [10. 返回最高成绩的学生人数并保存记录 (第82-83页)](#10. 返回最高成绩的学生人数并保存记录 (第82-83页))
  • [📑 C语言期末考试·新增题库分类笔记](#📑 C语言期末考试·新增题库分类笔记)
    • [📌 新增选择题考点分布](#📌 新增选择题考点分布)
      • [📂 第一章：概述与基本概念](#📂 第一章：概述与基本概念)
        • [考点 1：注释、分号与程序基本单位判定](#考点 1：注释、分号与程序基本单位判定)
        • [考点 2：C程序的编译、执行与机器指令转换](#考点 2：C程序的编译、执行与机器指令转换)
        • [考点 3：C程序构成与 `main` 函数位置](#考点 3：C程序构成与 main 函数位置)
      • [📂 第二章：数据类型、运算符和表达式](#📂 第二章：数据类型、运算符和表达式)
        • [考点 1：合法与非法用户标识符判定](#考点 1：合法与非法用户标识符判定)
        • [考点 2：常量与转义字符、字符串深度辨析](#考点 2：常量与转义字符、字符串深度辨析)
        • [考点 3：运算符优先级与结合性](#考点 3：运算符优先级与结合性)
        • [考点 4：混合类型转换、除法与逻辑真假](#考点 4：混合类型转换、除法与逻辑真假)
        • [考点 5：高级位运算与特殊赋值计算](#考点 5：高级位运算与特殊赋值计算)
      • [📂 第三章：算法和控制语句部分](#📂 第三章：算法和控制语句部分)
        • [考点 1：格式化输出修饰符 `%m.nf` 精度与宽度判定](#考点 1：格式化输出修饰符 %m.nf 精度与宽度判定)
        • [考点 2：条件、循环与逻辑边界判定](#考点 2：条件、循环与逻辑边界判定)
      • [📂 第四章：函数与局部/全局变量](#📂 第四章：函数与局部/全局变量)
        • [考点 1：形参实参占用单元规范](#考点 1：形参实参占用单元规范)
        • [考点 2：递归函数调用次数深度剖析](#考点 2：递归函数调用次数深度剖析)
        • [考点 3：变量隐含存储类型与生存期](#考点 3：变量隐含存储类型与生存期)
        • [考点 4：标准库函数的重定义约束](#考点 4：标准库函数的重定义约束)
      • [📂 第五章：数组](#📂 第五章：数组)
        • [考点 1：一维数组定义界限规范](#考点 1：一维数组定义界限规范)
      • [📂 第六章：指针](#📂 第六章：指针)
        • [考点 1：指针变量代表地址的选项组合判定](#考点 1：指针变量代表地址的选项组合判定)
        • [考点 2：不能表示数组元素的表达式判定](#考点 2：不能表示数组元素的表达式判定)
        • [考点 3：指针数组与行指针的混淆辨析](#考点 3：指针数组与行指针的混淆辨析)
      • [📂 第七章：预编译指令](#📂 第七章：预编译指令)
        • [考点 1：宏替换的本质](#考点 1：宏替换的本质)
        • [考点 2：`#include` 尖括号 `<>` 与双引号 `""` 的检索路径区别](#include尖括号<>与双引号""` 的检索路径区别)
        • [考点 3：带参数的宏展开嵌套求值](#考点 3：带参数的宏展开嵌套求值)
      • [📂 第八章：结构体与共用体、文件操作大类](#📂 第八章：结构体与共用体、文件操作大类)
        • [考点 1：共用体 `union` 内存分配特征](#考点 1：共用体 union 内存分配特征)
        • [考点 2：结构体生存期与内存驻留](#考点 2：结构体生存期与内存驻留)
        • [考点 3：文件操作常用库函数](#考点 3：文件操作常用库函数)
    • [📝 新增上机操作题源码（填空与改错）](#📝 新增上机操作题源码（填空与改错）)
      • [1️⃣ 降序数组合并算法](#1️⃣ 降序数组合并算法)
      • [2️⃣ 提取二维数组中每列最大元素的平均值](#2️⃣ 提取二维数组中每列最大元素的平均值)
      • [3️⃣ 字符串处理：在串首插入指定字符](#3️⃣ 字符串处理：在串首插入指定字符)
      • [4️⃣ 右下拐角与左上拐角方阵生成](#4️⃣ 右下拐角与左上拐角方阵生成)
      • [5️⃣ 统计并输出一个正整数各位数码中 0 的个数](#5️⃣ 统计并输出一个正整数各位数码中 0 的个数)
      • [6️⃣ 字符串边界清除：删除字符串中间的 `*` 号](#6️⃣ 字符串边界清除：删除字符串中间的 * 号)
      • [7️⃣ 二维矩阵按顺时针/逆时针方向旋转90度](#7️⃣ 二维矩阵按顺时针/逆时针方向旋转90度)

📑 C语言期末考试·新增题库分类笔记

📌 新增选择题考点分布

📂 第一章：概述与基本概念

考点 1：注释、分号与程序基本单位判定
  • 正确叙述 ：C程序中注释部分可以出现在程序中任意合适的地方。
  • 错误纠正 ：
    • 分号是C语句的一部分/结束符（不能说是分隔符）。
    • 花括号不仅能作为函数体定界符，还能用作复合语句和结构体的定界符。
    • 所有函数名中，main 函数名是系统规定的，用户不能随意命名。
  • 注释界定符 ：C语言的标准注释界定符是 /* */。
考点 2：C程序的编译、执行与机器指令转换
  • 正确叙述 ：C语言的每条可执行语句 最终都将被转换成二进制的机器指令。
  • 编译后缀 ：C语言源程序文件后缀为 .c，经过编译程序编译后生成的目标文件 后缀为 .obj。(注：链接后生成的可执行文件后缀才是 .exe)。
  • 错误纠正 ：
    • 源程序必须经过编译链接才能运行。
    • C语言的函数可以单独进行编译。
考点 3：C程序构成与 main 函数位置
  • 函数位置 ：在一个C程序中，main 函数可以出现在任何地方。
  • 构成单位 ：C程序由函数组成。一个C程序只能有一个主函数。

📂 第二章：数据类型、运算符和表达式

考点 1：合法与非法用户标识符判定
  • 核心规则 ：只能由字母、数字、下划线 组成，且不能以数字开头 ，同时不能是C语言关键字（区分大小写）。
  • 不合法标识符示例 ：
    • b-a, goto, int → \rightarrow → 包含非法字符减号 -，且 goto 和 int 是系统关键字。
    • -123, temp, INT → \rightarrow → 以减号开头。
    • -A → \rightarrow → 以减号开头。
    • p-0 → \rightarrow → 包含非法字符减号 -。
    • A.dat → \rightarrow → 包含非法字符点号 .。
    • 3Dmax → \rightarrow → 以数字开头。
    • long → \rightarrow → 属于系统关键字。
  • 合法标识符示例 ：
    • PRINTF → \rightarrow → 合法（C语言关键字是小写的 printf）。
    • FOR → \rightarrow → 合法（关键字是小写的 for）。
    • WORD → \rightarrow → 合法。
    • _group_6 → \rightarrow → 合法。
    • _2Test → \rightarrow → 合法。
    • _3xyz → \rightarrow → 合法。
  • 系统关键字 ：
    • 属于关键字的是 default。而 integer, VAR, cher 均不是关键字。
    • 不能用作自定义标识符的是 Float。(注：在标准语法中，小写关键字如 sizeof、float 等绝对不能作为自定义标识符)。
考点 2：常量与转义字符、字符串深度辨析
  • 非法转义字符定义 ：char s='\092';
    • 判定 ：定义不合法，s的值不确定 。因为八进制转义字符 \ddd 规定每位数字只能是 0~7，不可能出现 9。
  • 八进制转义字符求值 ：已知大写A是65，小写a是97。八进制常量 '\101' 是多少？
    • 判定 ：八进制 101 转换为十进制为 1 × 8 2 + 0 × 8 1 + 1 × 8 0 = 64 + 1 = 65 1 \times 8^2 + 0 \times 8^1 + 1 \times 8^0 = 64 + 1 = 65 1×82+0×81+1×80=64+1=65。十进制 65 对应的正是字符A。
  • 字符数组与字符串截断 ：char c[5]={'a','b','\0','c','\0'}; 执行 printf("%s", c);
    • 判定 ：输出结果为 ab 。因为 %s 格式化输出在遇到第一个字符串结束符 '\0' 时就会停止输出。
  • 合法字符串量 ：
    • 属于字符串常量的是 "house"（字符串必须用双引号包裹）。
    • 'y=' 是错误的（单引号内不能有多个字符，属于非法常量）。
考点 3：运算符优先级与结合性
  • 优先级顺序 ：下列运算符中优先级最高的是（ + ）。
    • 标准优先级顺序 ：算术运算符（+） > > > 关系运算符（<） > > > 不等于运算符（!=） > > > 逻辑与（&&）。
    • 混合大类顺序 ：算术运算 > > > 关系运算 > > > 赋值运算。
  • 赋值表达式特征 ：在赋值表达式中，赋值号右边既可以是变量也可以是任意表达式。
  • 连续复合赋值计算 ：int k=2, i=2, m; m=(k+=i*=k); 执行后 m 和 i 的值？
    • 解析 ：复合赋值运算符满足自右向左 结合。
      1. 先算右边：i *= k → \rightarrow → i = 2 * 2 = 4。
      2. 再算左边：k += 4 → \rightarrow → k = 2 + 4 = 6。
      3. 最终赋值给 m，所以 m = 6，此时 i 已经变成了 4。
    • 答案 ：m 的值为 6 ，i 的值为 4。
  • 逗号表达式求值 ：int a=0,b=0,c=0; c=(a-=a-5),(a=b,b+3); 执行后输出？
    • 解析 ：注意括号和优先级！c=(a-=a-5) 是逗号表达式的第一项。
      1. a - 5 结果为 -5。
      2. a -= -5 相当于 a = 0 - (-5) = 5。
      3. 赋值给 c，此时 c = 5。
      4. 逗号表达式第二项 (a=b, b+3) 并不影响 c 的值。最终 a 通过 a=b 被赋为 0，b 保持 0。
    • 答案 ：变量a, b, c的值分别为 0, 0, 5。
考点 4：混合类型转换、除法与逻辑真假
  • 逻辑"真"的等价概念 ：C语言中，逻辑"真"等价于非零的数。
  • 自动类型转换提升 ：char w; int x; float y; double z; 则表达式 w*x+z-y 的数据类型为？
    • 判定 ：double。整个表达式中含有的最高级类型是 double，所有低级类型都会向高级类型看齐。
  • 整型除法截断 ：int c1=1, c2=2, c3; c3 = c1 / c2;
    • 判定 ：c3 中的值是 0 。因为整型做除法只保留整数部分 1 / 2 = 0 1 / 2 = 0 1/2=0。
考点 5：高级位运算与特殊赋值计算
  • 混合自增与三目运算符 ：int x=1,y=2,z=3; z+=x>y?++x:++y;
    • 计算 ：x>y 为假，执行 ++y → \rightarrow → y 变成 3，三目表达式整体返回 3。z += 3 → \rightarrow → z = 3 + 3 = 6。
    • 答案 ：z 的最终值为 6。
  • 连续复合运算（重点） ：
    • int a=12; a+=a-=a*a;
      • 从右向左算：a -= 144 → \rightarrow → a = 12 - 144 = -132。
      • 再算左边：a += -132 → \rightarrow → a = -132 + (-132) = -264。
      • 答案 ：-264。
    • int a=3; a-=a+=a*a;
      • 从右向左算：a += 9 → \rightarrow → a = 3 + 9 = 12。
      • 再算左边：a -= 12 → \rightarrow → a = 12 - 12 = 0。
      • 答案 ：0。

📂 第三章：算法和控制语句部分

考点 1：格式化输出修饰符 %m.nf 精度与宽度判定
  • 浮点数强制精度修饰 ：
    • float a=3.1415; printf("|%6.0f|\n", a);
      • 解析 ：.0 表示保留 0 位小数，进行四舍五入后浮点数部分变成 3。6 表示总输出占 6 列，默认右对齐，左补空格。
      • 结果 ：| 3| (注：中间包含 5 个空格)。
    • printf("|%10.5f|\n", 12345.678);
      • 解析 ：.5 表示保留 5 位小数，不足向后补 0 变成 12345.67800。此时字符串长度已经是 11 位，超过了指定的总宽度 10，因此按实际位宽完整输出。
      • 结果 ：|12345.67800|。
    • int x=12; double y=3.141593; printf("%d%8.6f",x,y);
      • 结果 ：123.141593。两者无缝拼接输出。
考点 2：条件、循环与逻辑边界判定
  • while表达式的值判定 ：while(t=1)
    • 判定 ：循环控制表达式的值为1（恒为真）。
  • 赋值型条件退出次数 ：for(i=2; i==0; ) 执行 0次 。因为中间条件是 i==0（初始 i=2 使得判定恒为假）。
  • while条件判定假值 ：while(i=0) 表达式值为 0，循环执行 0次。
  • while后带分号的空循环 ：int a=7; while(a--);
    • 判定 ：while 条件循环判断到 0 为假时退出，退出后受后置 -- 影响，a 最终的值变成 -1。

📂 第四章：函数与局部/全局变量

考点 1：形参实参占用单元规范
  • 判定 ：实参和其对应的形参各自占用独立的存储单元。在调用时进行值的单向传递。
考点 2：递归函数调用次数深度剖析

  • 代码片段 ：

    c 复制代码 
    int sum(int n) { if(n==0) return 0; else return n+sum(n-1); }

  • 问题 ：在执行 sum(10) 的过程中，调用sum函数的次数是？

  • 判定 ：11次 。从 sum(10) 递归调用至基准情况 sum(0)，共调用了 10 + 1 = 11 10 + 1 = 11 10+1=11 次。

考点 3：变量隐含存储类型与生存期
  • 隐含类型 ：C语言函数内定义的局部变量，隐含的存储类型是 auto（自动变量）。
  • 生存期特性 ：静态 (static) 类别变量的生存期贯穿于整个程序的运行期间。
  • 初值特性：未赋予初值的 static 变量，系统自动清零（初值为 0）；而 auto 变量初值是随机值。
考点 4：标准库函数的重定义约束
  • 规则 ：用户可以重新定义标准库函数，若如此，该函数将失去原有含义。系统底层允许覆盖，但实际开发中极不推荐。

📂 第五章：数组

考点 1：一维数组定义界限规范
  • 代码定义 ：int a[10];
  • 正确描述 ：定义一个一维数组a，共有 a0 到 a9 10 个数组元素 。下标从 0 开始，不存在 a[10] 这一项。

📂 第六章：指针

考点 1：指针变量代表地址的选项组合判定
  • 代码定义 ：设 int *point, a=4; point=&a;
  • 等价地址组合 ：&a, &*point, point 均代表地址。(注：*point 代表的是变量 a 的值 4，而不是地址)。
考点 2：不能表示数组元素的表达式判定
  • 代码定义 ：设 int a[10], *p=a;
  • 判定 ：*p++ 返回的是当前元素值并使指针后移。而形如 a[*p-a] 等属于根据值进行下标计算的合法元素引用。
考点 3：指针数组与行指针的混淆辨析
  • 指针数组 ：int *pa[5]; → \rightarrow → 方括号优先级高，它是一个具有 5 个元素的指针数组，每个元素都是一个指针。
  • 行指针 ：int (*p)[M]; → \rightarrow → 圆括号优先级高，它是一个指向具有 M 个整型元素的一维数组的行指针。

📂 第七章：预编译指令

考点 1：宏替换的本质
  • 代码定义 ：#define PI 3.1415926
  • 判定 ：宏名 PI 代替的是一个字符串。宏替换是在编译前进行的纯文本替换，不具备任何类型。
考点 2：#include 尖括号 <> 与双引号 "" 的检索路径区别
  • 尖括号 < > ：直接按系统设定的标准方式搜索目录（通常是系统包含目录）。
  • 双引号 "" ：先在源程序所在目录中搜索，若未找到，再按系统设定的标准方式搜索。
考点 3：带参数的宏展开嵌套求值

  • 题目示例 1 ：

    c 复制代码 
    #define MIN(x,y) (x)>(y)?(x):(y)
// 调用: k=10*MIN(i,j); 设 i=10, j=15
    • 避坑解析 ：宏替换只是纯粹的文本直接替换，绝没有函数调用的优先括号！
    • 文本展开 ：k = 10 * (10) > (15) ? (10) : (15);
    • 运算步骤 ：先算乘法 10 * 10 = 100 → \rightarrow → 关系判定 100 > 15 为真 → \rightarrow → 整个三目运算符取前者的值 10。
    • 答案 ：k 的最终值为 10。

  • 题目示例 2 ：

    c 复制代码 
    #define DOUBLE(r) (r*r)
// 调用: t=DOUBLE(x+y); 设 x=1, y=2
    • 文本展开 ：t = x + y * x + y;
    • 运算步骤 ：代入数据为 1 + 2 × 1 + 2 = 1 + 2 + 2 = 5 1 + 2 \times 1 + 2 = 1 + 2 + 2 = 5 1+2×1+2=1+2+2=5。
    • 答案 ：t 的最终值为 5。

📂 第八章：结构体与共用体、文件操作大类

考点 1：共用体 union 内存分配特征
  • 核心规则 ：共用体变量在系统分配内存时，其大小等于成员中占内存量最大的容量 。(对比：结构体是各成员所需容量的总和)。
考点 2：结构体生存期与内存驻留
  • 生存期规则 ：C语言结构体类型变量在其生存期内，所有成员一直驻留在内存中。
考点 3：文件操作常用库函数
  • 文件尾部判定 ：feof(fp) 当已读到文件末尾时，其返回值为非零值（真）。
  • 文件关闭返回值 ：当顺利执行了文件关闭操作，fclose(fp) 函数的返回值为 0。
  • 文件打开失败返回值 ：若执行 fopen 发生错误（如文件不存在），函数的返回值为 0 (即 NULL)。
  • 数据块写入函数格式 ：fwrite 函数的正确标准形式为 fwrite(buffer, size, count, fp);。
  • 位置指针偏移指令 ：fseek(fp, -20L, 2); 中的 2 代表文件末尾 SEEK_END。
    • 含义 ：将文件位置指针从文件末尾向后退 20 个字节。

📝 新增上机操作题源码（填空与改错）

1️⃣ 降序数组合并算法

  • 考点 ：双指针法（归并排序核心思想），将两个降序数组有序合并至数组 c 中。
  • 填空源码填补 ：
    • 【空1】 a[i++] (由于是降序大数优先，当 a[i] >= b[j] 时，将 a[i] 放入 c 数组，且指针 i 后移)
    • 【空2】 c[k++] = a[i++]
    • 【空3】 c[k++] = b[j++]

2️⃣ 提取二维数组中每列最大元素的平均值

  • 考点 ：二维矩阵的列优先遍历。外层循环控制列（j），内层循环控制行（i）。
  • 【Begin与End】间核心程序设计源码：
c 复制代码 
/*********Begin*********/
int i, j, max;
double avg = 0;
for (j = 0; j < n; j++) // 遍历列
{
    max = x[0][j];      // 假设当前列的第0行元素最大
    for (i = 1; i < m; i++)
    {
        if (x[i][j] > max)
            max = x[i][j];
    }
    avg += max;         // 累加每列的最大值
}
return avg / n;         // 返回平均值
/*********End**********/

3️⃣ 字符串处理：在串首插入指定字符

  • 考点：利用指针对字符串进行右移，腾出首位空间进行字符插入。
  • 填空源码填补 ：
    • 【空1】 char *p = str; (声明并初始化移动指针)
    • 【空2】 *p == ch (发现重复字符，直接打断退出)
    • 【空3】 *p == '\0' (未发现重复，指针移动到了串尾，需要执行插入)
    • 【空4】 *str = ch (在首地址处插入新字符)
    • 【空5】 fun(s, c) (主函数内调用入口)

4️⃣ 右下拐角与左上拐角方阵生成

  • 考点：二维方阵对角线及三角区域赋值逻辑改错。
  • 源码修复 ：
    • 【改错1】 for (j=0; j<=n; j++) → \rightarrow → 修正为 for (j=0; j<n; j++)
    • 【改错2】 x[i][j]=j; → \rightarrow → 修正为 x[i][j]=n-j; (依右下拐对称规律)
    • 【改错3】 x[i][j]=i; → \rightarrow → 修正为 x[i][j]=n-i;
    • 【改错4】 int a[][]; → \rightarrow → 修正为 int a[N][N]; (主函数形参/声明需指定列宽)

5️⃣ 统计并输出一个正整数各位数码中 0 的个数

  • 考点 ：while 循环结合 %10 和 /10 剥离并判断每一位数码。
  • 填空源码填补 ：
    • 【空1】 int count = 0; (初始化计数器)
    • 【空2】 "%d", &n (格式化读入整型)
    • 【空3】 n % 10 == 0 (判定当前个位是否为0)
    • 【空4】 n /= 10; (剥离移除已处理的个位)

6️⃣ 字符串边界清除：删除字符串中间的 * 号

  • 考点：三指针/多下标处理法，保留前导与后随的特定符号，仅删除中间部分。
  • 填空源码填补 ：
    • 【空1】 s[i] == '*' (前导 * 统计控制)
    • 【空2】 j = strlen(s) - 1 (定位到尾部字符)
    • 【空3】 k = i (保留核心有效数据的起始下标)
    • 【空4】 s[k++] = s[j++] (收尾数据无缝拼接移动)

7️⃣ 二维矩阵按顺时针/逆时针方向旋转90度

  • 考点：行列互换关系映射算法转换与数组名作为地址传参。
  • 源码修复 ：
    • 逆时针旋转 90 度公式转换位置 ：修正对应的下标映射关系为 y[i][j] = x[j][n-1-i];。
    • 主函数数组传参错误修正 ：fun(a[0][0], b[0][0], m, n); → \rightarrow → 修正为 fun(a, b, m, n); (传递数组名即数组首地址)。
复制代码
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结04AI科技热点日报 | 2026年07月01日052026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？062026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？072026 年 AI 大模型 & AI 编程工具实战全总结08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？10Trae国际版与国内版深度测评：AI原生IDE的双生花