内 容 简 介 本 书 由 6 章 组 成, 第 1 章 ~ 第 5 章 紧 扣 上 海 市 高 等 学 校 计 算 机 等 级 考 试 ( 二 级 C 程 序 设 计 ) 考 试 大 纲, 对 C 程 序 设 计 的 教 学 内 容 进 行 了 有 重 点 的 讲 解, 对 考 试 要 求 的 知

Transcription

1 程 序 设 计 (C) 等 级 考 试 辅 导 教 程 ( 上 海 市 高 校 计 算 机 应 用 能 力 考 试 ( 二 级 C) 辅 导 教 材 ) 夏 耘 王 学 光 臧 劲 松 黄 小 瑜 黄 春 梅 编 著 1

2 内 容 简 介 本 书 由 6 章 组 成, 第 1 章 ~ 第 5 章 紧 扣 上 海 市 高 等 学 校 计 算 机 等 级 考 试 ( 二 级 C 程 序 设 计 ) 考 试 大 纲, 对 C 程 序 设 计 的 教 学 内 容 进 行 了 有 重 点 的 讲 解, 对 考 试 要 求 的 知 识 点 逐 一 进 行 了 点 拨, 每 章 分 为 二 个 部 分 : 本 章 重 点 难 点 分 析 ; 典 型 案 例 第 6 章 介 绍 了 程 序 调 试 方 法 和 应 试 技 巧, 并 配 了 综 合 练 习, 同 时 给 出 了 程 序 设 计 解 题 思 路 本 书 能 使 读 者 在 短 时 间 内 强 化 C 程 序 设 计 考 试 的 全 部 知 识 点, 通 过 大 量 练 习 提 高 编 程 能 力 本 书 既 是 一 本 学 习 指 导 又 是 一 本 考 前 辅 导, 可 供 各 层 面 学 生 教 师 自 学 应 试 者 阅 读 也 可 以 作 为 计 算 机 等 级 考 试 培 训 班 的 教 学 参 考 书 和 辅 导 用 书 2

3 前 言 C 语 言 以 其 小 巧 灵 活 高 效 等 特 点 成 为 当 今 软 件 开 发 的 主 要 编 程 语 言, 近 年 来 不 少 高 校 已 C 程 序 设 计 语 言 作 为 大 学 生 的 入 门 语 言, 教 育 部 考 试 中 心 及 大 部 分 省 市 将 C 程 序 设 计 纳 入 计 算 机 等 级 考 试 的 科 目 本 书 是 根 据 上 海 市 高 等 学 校 计 算 机 等 级 考 试 ( 二 级 C 程 序 设 计 ) 考 试 大 纲 的 要 求, 由 命 题 组 专 家 和 一 线 教 师 结 合 多 年 的 教 学 经 验 以 及 出 题 范 围 重 点 和 难 点 的 研 究, 从 学 生 学 习 和 应 试 角 度 出 发 精 心 编 写 而 成 本 书 知 识 覆 盖 面 广, 考 点 命 中 率 高 本 书 注 重 基 本 概 念 的 系 统 化, 叙 述 简 明 扼 要, 书 中 的 每 章 紧 扣 考 试 大 纲, 对 考 试 要 求 的 知 识 点 逐 一 进 行 了 点 拨, 针 对 部 分 难 点 和 重 点, 采 用 理 论 链 接 的 方 式, 给 出 了 相 关 知 识 和 理 论 的 分 析, 本 书 内 容 精 炼, 结 构 合 理, 重 点 突 出, 对 读 者 可 能 遇 到 的 难 点 做 了 十 分 清 楚 和 详 细 的 阐 述 读 者 只 需 按 本 书 的 指 引, 就 能 在 短 时 间 内 强 化 C 程 序 设 计 考 试 的 全 部 知 识 点, 从 而 缩 短 了 备 考 时 间 本 书 每 章 分 为 二 个 部 分, 它 们 是 : 第 一 部 分 本 章 重 点 难 点 分 析 ( 紧 扣 C 程 序 设 计 的 考 点 ), 第 二 部 分 典 型 案 例 ( 对 典 型 习 题 进 行 解 析, 旨 在 帮 助 学 生 走 出 解 题 的 误 区, 并 能 通 过 典 型 习 题 归 纳 总 结 出 程 序 设 计 的 规 律 和 方 法 ) 本 书 是 C 程 序 设 计 的 学 习 及 应 试 指 导 ( 针 对 学 生 学 习 和 考 试 中 可 能 遇 到 的 问 题 给 出 了 指 导, 旨 在 帮 助 学 生 用 正 确 的 方 法 掌 握 C 程 序 设 计 知 识 和 备 考 ) 本 书 第 6 章 ( 旨 在 帮 助 学 生 归 纳 总 结 考 题 的 范 围 ) 为 了 帮 助 学 生 在 学 习 C 程 序 设 计 知 识 的 同 时 通 过 上 海 市 级 的 与 C 程 序 设 计 相 关 的 计 算 机 等 级 考 试, 本 书 的 附 录 也 给 出 了 上 海 市 高 等 学 校 计 算 机 等 级 考 试 ( 二 级 C 程 序 设 计 ) 往 年 试 题 本 书 既 是 一 本 学 习 指 导 又 是 一 本 考 前 辅 导, 它 整 理 了 课 上 的 教 案, 注 重 训 练 环 节, 体 现 了 在 理 论 指 导 下, 让 学 生 动 手 动 脑 的 基 本 思 想 方 法, 提 出 理 性 思 维 和 理 性 实 践 按 照 建 构 主 义 的 学 习 理 论, 学 生 作 为 学 习 的 主 体 在 与 客 观 环 境 ( 指 所 学 内 容 ) 的 交 互 过 程 中 构 建 自 己 的 知 识 结 构 本 书 引 导 学 生 在 解 题 编 程 中 探 索 其 中 带 规 律 性 的 认 识, 将 感 性 认 识 升 华 到 理 性 高 度, 这 样 学 生 就 能 举 一 反 三 本 书 可 供 各 层 面 学 生 教 师 自 学 应 试 者 阅 读 也 可 以 作 为 计 算 机 等 级 考 试 培 训 班 的 教 学 参 考 书 和 辅 导 用 书 本 书 主 编 为 上 海 理 工 大 学 计 算 机 基 础 教 学 专 家 夏 耘 华 东 政 法 学 院 的 王 学 光 副 主 编 为 上 海 理 工 大 学 计 算 机 基 础 教 师 臧 劲 松 参 加 编 写 的 有 上 海 理 工 大 学 黄 小 瑜 黄 春 梅, 陈 章 徐 宇 清 担 任 本 书 主 审 是 计 算 机 等 级 考 试 命 题 组 专 家 茅 忠 明 教 授 在 编 写 过 程 中, 还 组 织 了 集 体 统 稿 定 稿, 并 得 到 了 清 华 大 学 交 通 大 学 复 旦 大 学 华 东 理 工 大 学 上 海 理 工 大 学 上 海 电 机 学 院 建 桥 学 院 上 海 大 学 等 校 计 算 中 心 各 位 老 师 的 帮 助 在 此 一 并 致 谢 由 于 时 间 仓 促 和 水 平 有 限, 本 书 中 难 免 还 存 在 一 些 不 妥 之 处, 请 广 大 读 者 批 评 指 正 3

4 目 录 第 1 章 程 序 设 计 基 础 认 识 C 语 言 数 据 类 型 与 运 算 符 语 句 输 入 输 出 格 式 格 式 输 入 函 数 scanf() 和 格 式 输 出 函 数 printf() 字 符 输 入 函 数 getchar() 和 字 符 输 出 函 数 putchar() 典 型 案 例 分 析 第 2 章 模 块 设 计 函 数 的 定 义 无 参 函 数 的 定 义 形 式 有 参 函 数 的 定 义 形 式 函 数 的 调 用 函 数 调 用 的 一 般 形 式 函 数 的 返 回 值 对 被 调 用 函 数 的 声 明 函 数 的 嵌 套 调 用 函 数 的 递 归 调 用 函 数 的 参 数 变 量 的 作 用 域 和 存 储 类 别 变 量 的 作 用 域 变 量 的 存 储 类 别 内 部 函 数 和 外 部 函 数 典 型 案 例 分 析 第 3 章 数 组 与 指 针 一 维 数 组 一 维 数 组 的 定 义 一 维 数 组 的 初 始 化 及 一 维 数 组 元 素 的 引 用 二 维 数 组 二 维 数 组 的 定 义 二 维 数 组 的 初 始 化 及 二 维 数 组 元 素 的 引 用 字 符 数 组 与 字 符 串 字 符 数 组 的 定 义 字 符 数 组 的 初 始 化 及 字 符 数 组 元 素 的 引 用 字 符 串 字 符 数 组 的 输 入 输 出 字 符 串 处 理 函 数 数 组 作 为 函 数 参 数 数 组 元 素 作 函 数 参 数 数 组 名 作 函 数 参 数

5 3.5 指 针 指 针 基 本 概 念 指 针 常 见 的 运 算 指 针 与 数 组 的 关 系 指 向 一 维 数 组 的 指 针 变 量 指 针 数 组 指 针 与 函 数 典 型 案 例 分 析 第 4 章 结 构 体 和 链 表 结 构 体 结 构 体 类 型 的 定 义 和 变 量 的 声 明 结 构 体 变 量 的 存 储 与 成 员 的 引 用 结 构 体 数 组 函 数 之 间 结 构 体 变 量 的 数 据 传 递 指 向 结 构 变 量 的 指 针 共 用 体 链 表 概 念 链 表 的 基 础 操 作 典 型 案 例 分 析 第 5 章 数 据 文 件 数 据 文 件 的 函 数 文 件 指 针 文 件 打 开 与 关 闭 文 件 定 位 文 件 的 出 错 检 测 和 处 理 数 据 文 件 的 读 单 个 字 符 的 读 字 符 串 的 读 数 据 块 读 格 式 化 读 数 据 文 件 的 写 单 个 字 符 的 写 字 符 串 的 写 数 据 块 写 格 式 化 写 典 型 案 例 分 析 第 6 章 应 试 指 南 概 念 题 分 析 程 序 改 错 题 分 析 程 序 填 空 题 分 析 编 程 题 分 析 年 试 题 年 试 题 预 测

6 6

7 第 1 章 程 序 设 计 基 础 数 据 类 型 是 程 序 中 数 据 的 组 织 形 式, 运 算 符 则 是 对 程 序 中 数 据 进 行 运 算 的 工 具 一 个 程 序 离 不 开 数 据, 而 数 据 在 内 存 中 妥 善 存 储 与 安 全 传 输 需 要 定 义 其 数 据 类 型, 数 据 间 的 运 算 需 要 运 算 符 的 帮 助 C 语 言 程 序 由 多 个 函 数 定 义 体 组 成, 其 中 main 函 数 是 必 须 定 义 的 函 数, 它 是 程 序 的 入 口 和 出 口 程 序 的 功 能 是 由 组 成 它 的 函 数 之 间 的 调 用 关 系 决 定 的 只 写 一 个 main 函 数 也 可 以 实 现 程 序 的 全 部 功 能, 但 不 利 于 程 序 的 维 护 程 序 功 能 的 实 现 则 需 要 语 句 的 帮 助, 语 句 是 处 理 事 物 的 必 要 工 具 图 1-1 数 据 类 型 及 基 本 运 算 知 识 网 络 图 1.1 认 识 C 语 言 1. C 语 言 的 产 生 与 发 展 C 语 言 是 1972 年 由 美 国 的 Dennis Ritchie 设 计 发 明 的, 并 首 次 在 UNIX 操 作 系 统 的 DEC PDP-11 计 算 机 上 使 用 它 由 早 期 的 编 程 语 言 BCPL (Basic Combind Programming Language) 发 展 演 变 而 来 在 1970 年,AT&T 贝 尔 实 验 室 的 Ken hompson 根 据 BCPL 语 言 设 计 出 较 先 进 的 并 取 名 为 B 的 语 言, 最 后 导 致 了 C 语 言 的 问 世 随 着 微 型 计 算 机 的 日 益 普 及, 出 现 了 许 多 C 语 言 版 本 由 于 没 有 统 一 的 标 准, 使 得 这 些 C 语 言 之 间 出 现 了 一 些 不 一 致 的 地 方 为 了 改 变 这 种 情 况, 美 国 国 家 标 准 研 究 所 (ANSI) 为 C 语 言 制 定 了 一 套 ANSI 标 准, 成 为 现 行 的 C 语 言 标 准 2.C 语 言 的 特 点 7

8 (1) 语 言 简 洁 使 用 方 便 易 学 易 用 (2) 运 算 丰 富 (3)C 语 言 中 的 数 据 类 型 丰 富 (4) 程 序 结 构 化 (5) 具 有 位 操 作 能 力, 能 够 直 接 访 问 物 理 地 址 (6)C 语 言 功 能 齐 全 (7) 适 用 范 围 大 3.C 语 言 的 开 发 平 台 Visual C++6.0 编 程 环 境 是 Microsoft 公 司 出 品 的 基 于 Windows 环 境 的 C/C++ 开 发 工 具, 它 是 Microsoft Visual Stdio 套 装 软 件 的 一 个 组 成 部 分 C 源 程 序 可 以 在 VC++6.0 集 成 环 境 中 进 行 编 译 连 接 和 运 行 利 用 Visual C++6.0 编 程 环 境 建 立 应 用 程 序 的 步 骤 如 下, 即 : 第 1 步 : 进 入 Visual C++ 环 境 后, 打 开 文 件 菜 单, 执 行 新 建 命 令 第 2 步 : 在 新 建 对 话 框 中 选 择 文 件 选 项 卡, 然 后 选 择 C++ Source File 选 项 第 3 步 : 在 对 话 框 右 边 的 目 录 文 本 框 中 输 入 准 备 编 辑 的 源 程 序 文 件 的 存 储 路 径, 在 文 件 文 本 框 中 输 入 准 备 编 辑 的 C 源 程 序 文 件 名 ( 如 :sy1_1.c) 注 意 后 缀 是.c 然 后 按 确 定 按 钮 第 4 步 : 在 光 标 闪 烁 的 程 序 编 辑 窗 口 输 入 上 面 C 程 序 ( 注 意 :/* */ 之 间 的 内 容 为 程 序 注 释 部 分, 不 执 行 ), 程 序 输 入 完 毕 单 击 文 件 / 保 存, 或 单 击 工 具 栏 上 的 保 存 按 钮, 也 可 以 用 <Ctrl+S> 快 捷 键 来 保 存 文 件 第 5 步 : 选 择 菜 单 编 译 / 编 译 命 令, 或 单 击 工 具 栏 上 的 编 译 图 标, 也 可 以 按 <Ctrl+F7> 键, 启 动 编 译 系 统, 观 察 调 试 信 息 窗 口 输 出 的 编 译 信 息, 如 果 有 错, 则 修 改 后 再 编 译, 直 至 编 译 信 息 为 :0 error(s),0 warning(s) 表 示 编 译 成 功 第 6 步 : 单 击 <F7> 键 或 工 具 栏 图 标, 生 成 应 用 程 序 的.EXE 文 件 ( 如 sy1_1.exe) 第 7 步 : 运 行 程 序 观 察 结 果 选 择 菜 单 编 译 / 执 行, 或 单 击 工 具 栏 上 的 执 行 图 标 提 示 :Visual C++6.0 编 程 环 境 建 立 应 用 程 序 在 debug 文 件 夹 下 ( 如 :C 源 程 序 文 件 名 sy1_1.c,debug 文 件 夹 下 就 存 在 一 个 sy1_1.exe 文 件 ) 1.2 数 据 类 型 与 运 算 符 1. 常 量 和 变 量 在 程 序 运 行 过 程 中 其 值 保 持 不 变 的 量 称 为 常 量 常 量 可 以 分 为 直 接 常 量 和 符 号 常 量 在 C 语 言 中, 可 以 用 一 个 标 识 符 来 表 示 一 个 常 量, 称 之 为 符 号 常 量 符 号 常 量 在 使 用 之 前 必 须 先 定 义, 其 一 般 形 式 为 : #define 标 识 符 常 量 其 中 #define 也 是 一 条 预 处 理 命 令 ( 预 处 理 命 令 都 以 "#" 开 头 ), 称 为 宏 定 义 命 令, 其 功 能 是 把 该 标 识 符 定 义 为 其 后 的 常 量 值 一 经 定 义, 以 后 在 程 序 中 所 有 出 现 该 标 识 符 的 地 方 均 代 之 以 该 常 量 值 在 使 用 符 号 常 量 时 应 注 意 : 习 惯 上 符 号 常 量 的 标 识 符 用 大 写 字 母, 变 量 标 识 符 用 小 写 字 母, 以 示 区 别 符 号 而 变 量 则 必 须 先 定 义 后 使 用 8

9 变 量 是 内 存 或 寄 存 器 中 用 一 个 标 识 符 命 名 的 存 储 单 元, 可 以 用 来 存 储 一 个 特 定 类 型 的 数 据, 并 且 数 据 的 值 在 程 序 运 行 过 程 中 可 以 进 行 修 改 一 旦 定 义 了 变 量, 那 么, 变 量 就 至 少 可 为 我 们 提 供 两 个 信 息 : 一 是 变 量 的 地 址, 即 : 操 作 系 统 为 变 量 在 内 存 中 分 配 的 若 干 内 存 的 首 地 址 ; 二 是 变 量 的 值, 也 就 是, 变 量 在 内 存 中 所 分 配 的 那 些 内 存 单 元 中 所 存 放 的 数 据 变 量 定 义 的 一 般 形 式 为 : 类 型 说 明 符 变 量 名 标 识 符, 变 量 名 标 识 符,...; 在 书 写 变 量 定 义 时, 应 注 意 以 下 几 点 : 允 许 在 一 个 类 型 说 明 符 后, 定 义 多 个 相 同 类 型 的 变 量 各 变 量 名 之 间 用 逗 号 间 隔 类 型 说 明 符 与 变 量 名 之 间 至 少 用 一 个 空 格 间 隔 最 后 一 个 变 量 名 之 后 必 须 以 ; 号 结 尾 变 量 必 须 先 有 确 定 的 值 后 才 能 参 与 各 种 相 应 的 操 作, 变 量 获 取 数 据 的 途 径 有 三 种, 即 : 通 过 键 盘 输 入 ( 如 :scanf("%d ",&a);) 通 过 赋 值 语 句 赋 值 ( 如 :a=3; ) 通 过 初 始 化 方 式 赋 初 值 ( 如 :int a=3;) 所 谓 初 始 化 是 指 在 定 义 变 量 的 同 时 指 定 变 量 的 初 值, 形 式 为 : 数 据 类 型 变 量 名 = 表 达 式 ; * 不 允 许 为 多 个 变 量 同 时 初 始 化 2.C 语 言 中 的 关 键 字 C 语 言 的 所 有 命 令, 系 统 函 数 名 等, 称 为 C 语 言 的 关 键 字 它 们 是 专 字 专 用, 通 过 它 们 向 计 算 机 发 出 指 令, 完 成 指 定 的 任 务 C 语 言 程 序 都 是 以 main 为 口 的,C 语 言 中 的 关 键 字 为 : auto : 声 明 自 动 变 量 一 般 不 使 用 double : 声 明 双 精 度 变 量 或 函 数 int: 声 明 整 型 变 量 或 函 数 struct: 声 明 结 构 体 变 量 或 函 数 break: 跳 出 当 前 循 环 else : 条 件 语 句 否 定 分 支 ( 与 if 连 用 ) long : 声 明 长 整 型 变 量 或 函 数 switch : 用 于 开 关 语 句 case: 开 关 语 句 分 支 enum : 声 明 枚 举 类 型 register: 声 明 积 存 器 变 量 typedef: 用 以 给 数 据 类 型 取 别 名 ( 当 然 还 有 其 他 作 用 ) char : 声 明 字 符 型 变 量 或 函 数 extern: 声 明 变 量 是 在 其 他 文 件 正 声 明 ( 也 可 以 看 做 是 引 用 变 量 ) return : 子 程 序 返 回 语 句 ( 可 以 带 参 数, 也 看 不 带 参 数 ) union: 声 明 联 合 数 据 类 型 const : 声 明 只 读 变 量 float: 声 明 浮 点 型 变 量 或 函 数 short : 声 明 短 整 型 变 量 或 函 数 unsigned: 声 明 无 符 号 类 型 变 量 或 函 数 continue: 结 束 当 前 循 环, 开 始 下 一 轮 循 环 for: 一 种 循 环 语 句 ( 可 意 会 不 可 言 传 ) 9

10 signed: 生 命 有 符 号 类 型 变 量 或 函 数 void : 声 明 函 数 无 返 回 值 或 无 参 数, 声 明 无 类 型 指 针 ( 基 本 上 就 这 三 个 作 用 ) default: 开 关 语 句 中 的 其 他 分 支 goto: 无 条 件 跳 转 语 句 sizeof: 计 算 数 据 类 型 长 度 volatile: 说 明 变 量 在 程 序 执 行 中 可 被 隐 含 地 改 变 do : 循 环 语 句 的 循 环 体 while : 循 环 语 句 的 循 环 条 件 static : 声 明 静 态 变 量 if: 条 件 语 句 3.C 语 言 中 的 数 据 类 型 数 据 类 型 是 按 被 定 义 变 量 的 性 质, 表 示 形 式, 占 据 存 储 空 间 的 多 少, 构 造 特 点 来 划 分 的 在 C 语 言 中, 数 据 类 型 可 分 为 以 下 几 类 : 1. 基 本 数 据 类 型 : 基 本 数 据 类 型 最 主 要 的 特 点 是, 其 值 不 可 以 再 分 解 为 其 它 类 型 也 就 是 说, 基 本 数 据 类 型 是 自 我 说 明 的 2. 构 造 数 据 类 型 : 构 造 数 据 类 型 是 根 据 已 定 义 的 一 个 或 多 个 数 据 类 型 用 构 造 的 方 法 来 定 义 的 也 就 是 说, 一 个 构 造 类 型 的 值 可 以 分 解 成 若 干 个 成 员 或 元 素 每 个 成 员 都 是 一 个 基 本 数 据 类 型 或 又 是 一 个 构 造 类 型 在 C 语 言 中, 构 造 类 型 有 以 下 几 种 : 数 组 类 型 结 构 体 类 型 共 用 体 ( 联 合 ) 类 型 3. 指 针 类 型 : 指 针 是 一 种 特 殊 的, 同 时 又 是 具 有 重 要 作 用 的 数 据 类 型 其 值 用 来 表 示 某 个 变 量 在 内 存 储 器 中 的 地 址 虽 然 指 针 变 量 的 取 值 类 似 于 整 型 量, 但 这 是 两 个 类 型 完 全 不 同 的 量, 因 此 不 能 混 为 一 谈 4. 空 类 型 : 在 调 用 函 数 值 时, 通 常 应 向 调 用 者 返 回 一 个 函 数 值 这 个 返 回 的 函 数 值 是 具 有 一 定 的 数 据 类 型 的, 应 在 函 数 定 义 及 函 数 说 明 中 给 以 说 明, 例 如,max 函 数 定 义 中, 函 数 头 为 :int max(int a,int b); 其 中 int 类 型 说 明 符 即 表 示 该 函 数 的 返 回 值 为 整 型 量 又 如, 使 用 了 库 函 数 sin, 由 于 系 统 规 定 其 函 数 返 回 值 为 双 精 度 浮 点 型, 因 此 在 赋 值 语 句 s=sin (x); 中,s 也 必 须 是 双 精 度 浮 点 型, 以 便 与 sin 函 数 的 返 回 值 一 致 所 以 在 说 明 部 分, 把 s 说 明 为 双 精 度 浮 点 型 但 是, 也 有 一 类 函 数, 调 用 后 并 不 需 要 向 调 用 者 返 回 函 数 值, 这 种 函 数 可 以 定 义 为 空 类 型 其 类 型 说 明 符 为 void 4. 基 本 的 数 据 类 型 1. 整 型 根 据 整 型 数 据 在 计 算 机 内 部 编 码 的 差 异, 将 整 型 数 据 分 为 : 无 符 号 基 本 型 : 类 型 说 明 符 为 unsigned int 或 unsigned 有 符 号 基 本 型 : 类 型 说 明 符 为 signed int 或 int 无 符 号 短 整 型 : 类 型 说 明 符 为 unsigned short 有 符 号 短 整 量 : 类 型 说 明 符 为 signed short int 或 short 无 符 号 长 整 型 : 类 型 说 明 符 为 unsigned long 有 符 号 长 整 型 : 类 型 说 明 符 为 signed long int 或 long 无 符 号 型 : 类 型 说 明 符 为 unsigned 2. 实 型 实 型 数 据 在 内 存 中 的 存 放 形 式 实 型 数 据 一 般 占 4 个 字 节 (32 位 ) 内 存 空 间 按 指 数 形 式 存 储 实 数 在 内 存 10

11 中 的 存 放 形 式 如 下 : 数 符 小 数 部 分 指 数 小 数 部 分 占 的 位 (bit) 数 愈 多, 数 的 有 效 数 字 愈 多, 精 度 愈 高 指 数 部 分 占 的 位 数 愈 多, 则 能 表 示 的 数 值 范 围 愈 大 实 型 变 量 的 分 类 : 实 型 变 量 分 为 : 单 精 度 (float 型 ) 双 精 度 (double 型 ) 和 长 双 精 度 (long double 型 ) 三 类 实 型 变 量 定 义 的 格 式 和 书 写 规 则 与 整 型 相 同 3. 字 符 变 量 字 符 变 量 的 类 型 说 明 符 是 char, 字 符 变 量 用 来 存 储 字 符 常 量, 即 单 个 字 符 字 符 变 量 类 型 定 义 的 格 式 和 书 写 规 则 都 与 整 型 变 量 相 同 应 该 特 别 注 意 字 符 数 据 在 内 存 中 的 存 储 形 式 及 使 用 方 法 : 字 符 变 量 被 分 配 一 个 字 节 的 内 存 空 间, 因 此 只 能 存 放 一 个 字 符 字 符 值 是 以 ASCII 码 的 形 式 存 放 在 变 量 的 内 存 单 元 之 中 的 所 以 也 可 以 把 它 们 看 成 是 整 型 量 C 语 言 允 许 对 整 型 变 量 赋 以 字 符 值, 也 允 许 对 字 符 变 量 赋 以 整 型 值 在 输 出 时, 允 许 把 字 符 变 量 按 整 型 量 输 出, 也 允 许 把 整 型 量 按 字 符 量 输 出 整 型 量 为 二 字 节 量, 字 符 量 为 单 字 节 量, 当 整 型 量 按 字 符 型 量 处 理 时, 只 有 低 八 位 字 节 参 与 处 理 5. 运 算 符 C 语 言 中 运 算 符 具 有 三 个 属 性 : 优 先 级 : 指 运 算 的 先 后 次 序, 共 分 15 个 级 别 ( 见 光 盘 ) 结 合 性 : 指 相 同 的 优 先 级 运 算 符 连 续 出 现 时 的 计 算 顺 序, 分 自 左 向 右 和 自 右 向 左 两 种, 除 特 别 声 明 外, 皆 指 自 左 向 右 目 数 : 指 运 算 符 要 求 的 操 作 数 的 个 数, 包 括 单 目 双 目 和 三 目, 一 般 目 数 越 少, 优 先 级 越 高 表 达 式 : 由 常 量 变 量 函 数 调 用 和 运 算 符 按 一 定 规 律 组 合 在 一 起 构 成 的 式 子 表 1-1 运 算 符 分 类 表 运 算 符 类 型 用 途 主 要 运 算 符 号 运 算 对 象 的 数 据 运 算 结 果 的 注 意 点 类 型 数 据 类 型 算 术 运 算 符 用 于 各 类 数 值 运 算 加 (+) 减 (-) 乘 (*) 除 (/) 求 余 ( 或 称 模 运 算,%) 自 增 (++) 自 减 (--) 共 7 种 任 意 ( 求 余 除 外 ) 运 算 前 按 运 算 对 象 中 数 据 类 型 进 行 自 动 转 换 后 最 终 的 数 据 类 型 就 是 运 算 结 果 的 数 据 类 型 求 余 运 算 要 求 运 算 对 象 为 整 型, 在 除 法 运 算 中, 当 两 个 操 作 数 都 是 整 数 时, 商 也 为 整 数, 小 数 部 分 一 律 舍 去 1/2 的 运 算 结 果 为 0 1.0/2 的 运 算 结 果 为 0.5 自 增 (++) 自 减 (--) 运 算 符 : ++i, --i ( 在 使 用 i 之 前, 先 使 i 的 值 加 减 1) 11

12 i++, i-- ( 在 使 用 i 之 后, 使 i 的 值 加 减 1) 自 增 自 减 运 算 符 只 能 用 于 变 量, 而 不 能 用 于 常 量 和 表 达 式 多 运 算 符 组 合 时 按 自 左 到 右, 运 算 符 尽 可 能 多 的 原 则 处 理, 如 i+++j, 理 解 为 (i++)+j 关 系 运 算 符 描 述 的 是 一 大 于 (>) 小 于 任 意 真 关 系 运 算 符 属 于 双 种 判 断 关 (<) 等 于 (==) (true) 和 目 运 算 符, 其 结 合 方 系 大 于 等 于 (>=) 假 向 为 自 左 至 右 两 个 小 于 等 于 (<=) (false) 两 表 达 式 通 过 关 系 运 和 不 等 于 (!=) 种 用 1 算 符 连 接 成 为 关 系 共 6 种 代 表 真, 表 达 式 关 系 运 算 中 用 0 代 常 常 会 误 解, 认 为 : 表 假 C 语 言 中 只 有 整 数 1 才 代 表 真 其 实, 正 确 概 念 是 : 无 论 是 整 数 还 是 实 数, 只 要 是 非 零, 就 为 真 逻 辑 运 算 符 逻 辑 运 算 通 与 (&&) 或 任 意 0(false) 和 算 术 运 算 符 逻 辑 运 常 用 来 连 接 ( ) 非 (!) 共 1(true) 算 符 和 关 系 运 算 符 关 系 运 算 3 种 三 者 间 的 优 先 级 关 系 为 :! 算 术 运 算 符 关 系 运 算 符 && 当 多 个 && 连 续 出 现 时, 如 表 达 式 1&& 表 达 式 2 && 表 达 式 3 从 左 到 右, 只 要 一 个 操 作 数 为 0, 结 果 就 为 0, 不 进 行 后 续 运 算 当 多 个 连 续 出 现 时, 如 表 达 式 1 表 达 式 2 表 达 式 3 从 左 到 右, 只 要 一 个 操 作 数 为 1, 结 果 就 为 1, 不 12

13 进 行 后 续 运 算 位 操 作 运 算 按 二 进 制 位 位 与 (&) 位 或 二 进 制 数 二 进 制 数 符 进 行 运 算 ( ) 位 非 (~) 位 异 或 (^) 左 移 (<<) 右 移 (>>) 共 6 种 条 件 运 算 符 按 表 达 式 1 的 任 意 表 任 意 是 C 语 言 中 唯 一 的 值 完 成 不 同 表 达 式 1? 表 一 个 三 目 运 算 符 一 的 任 务 达 式 2 : 表 达 式 3 般 而 言, 表 达 式 1 为 条 件 表 达 式, 当 其 成 立 时, 将 表 达 式 2 的 值 作 为 整 个 表 达 式 的 值, 不 再 计 算 表 达 式 3 的 值 ; 否 则 取 表 达 式 3 的 值 作 为 整 个 表 达 式 的 结 果, 而 不 计 算 表 达 式 2 的 值 条 件 运 算 符 的 优 先 级 比 关 系 运 算 符 算 术 运 算 符 逻 辑 运 算 符 都 低, 但 它 优 先 于 赋 值 运 算 符 赋 值 运 算 符 将 一 个 数 据 简 单 赋 值 (=) 任 意 与 赋 值 左 边 赋 值 号 左 边 必 须 是 赋 给 一 个 变 复 合 算 术 赋 值 的 变 量 类 型 变 量 结 合 性 是 : 自 量, 并 以 变 量 (+=,-=,*=,/=, 一 致 右 至 左 在 使 用 该 运 的 值 作 为 整 %=) 和 复 合 位 运 算 符 时, 要 注 意 同 一 个 式 子 的 值 算 赋 值 变 量 在 赋 值 号 两 边 (&=, =,^=,>>= 具 有 不 同 的 含 义 复,<<=)3 类 共 11 合 的 赋 值 运 算 符 是 种 由 算 术 运 算 符 与 赋 值 运 算 符 结 合 起 来 构 成 的, 如 :*=, /=,%=,+=,-= 它 们 既 可 以 进 行 算 术 运 算 又 能 完 成 赋 值 运 算 使 用 时 要 注 意 两 个 运 算 符 之 间 不 能 有 空 格 存 在 逗 号 运 算 符 把 两 个 或 多 个 算 术 表 达, 任 意 最 右 表 达 式 结 果 的 数 据 逗 号 表 达 式 的 求 值 顺 序 是 从 左 至 右, 且 式 连 接 起 来 类 型 就 是 逗 逗 号 运 算 符 是 所 有 号 表 达 式 的 运 算 符 中 优 先 级 别 13

14 结 果 最 低 的 一 种 运 算 符 例 如 下 面 两 个 表 达 式 将 得 到 不 同 的 计 算 结 果 : y=(a=4, 3*4) /*y 的 值 为 12, 逗 号 表 达 式 的 值 也 是 12*/ (y=a=4, 3*a) /*y 的 值 为 4, 逗 号 表 达 式 的 值 为 12*/ 指 针 运 算 符 完 成 对 内 存 取 内 容 (*) 和 取 由 运 算 符 确 定 由 运 算 符 确 单 元 的 访 问 地 址 (&) 共 2 种 定 求 字 节 数 运 计 算 某 种 数 sizeof( 数 据 或 任 意 整 型 sizeof(double)=8, 算 符 据 类 型 的 数 数 据 类 型 或 变 sizeof(f1)=8, 据 字 节 数 量 名 ) sizeof(9.8)=8 特 殊 运 算 符 (), 下 标 [ ], 成 员 (,.) 6. 运 算 符 优 先 级 和 结 合 性 一 般 而 言, 单 目 运 算 符 优 先 级 较 高, 赋 值 运 算 符 优 先 级 低 算 术 运 算 符 优 先 级 较 高, 关 系 和 逻 辑 运 算 符 优 先 级 较 低 多 数 运 算 符 具 有 左 结 合 性, 单 目 运 算 符 三 目 运 算 符 赋 值 运 算 符 具 有 右 结 合 性 表 达 式 是 由 运 算 符 连 接 常 量 变 量 函 数 所 组 成 的 式 子 每 个 表 达 式 都 有 一 个 值 和 类 型 表 达 式 求 值 按 运 算 符 的 优 先 级 和 结 合 性 所 规 定 的 顺 序 进 行 7. 各 类 数 值 型 数 据 之 间 的 混 合 运 算 变 量 的 数 据 类 型 是 可 以 转 换 的 转 换 的 方 法 有 两 种, 一 种 是 自 动 转 换, 一 种 是 强 制 转 换 (1) 自 动 转 换 发 生 在 不 同 数 据 类 型 的 量 混 合 运 算 时, 由 编 译 系 统 自 动 完 成 自 动 转 换 遵 循 以 下 规 则 : 若 参 与 运 算 量 的 类 型 不 同, 则 先 转 换 成 同 一 类 型, 然 后 进 行 运 算 转 换 按 数 据 长 度 增 加 的 方 向 进 行, 以 保 证 精 度 不 降 低 如 int 型 和 long 型 运 算 时, 先 把 int 量 转 成 long 型 后 再 进 行 运 算 所 有 的 浮 点 运 算 都 是 以 双 精 度 进 行 的, 即 使 仅 含 float 单 精 度 量 运 算 的 表 达 式, 也 要 先 转 换 成 double 型, 再 作 运 算 char 型 和 short 型 参 与 运 算 时, 必 须 先 转 换 成 int 型 在 赋 值 运 算 中, 赋 值 号 两 边 量 的 数 据 类 型 不 同 时, 赋 值 号 右 边 量 的 类 型 将 转 换 为 左 边 量 的 类 型 如 果 右 边 量 的 数 据 类 型 长 度 左 边 长 时, 将 丢 失 一 部 分 数 据, 这 样 会 降 低 精 度, 丢 失 的 部 分 按 四 舍 五 入 向 前 舍 入 (2) 强 制 类 型 转 换 强 制 类 型 转 换 是 通 过 类 型 转 换 运 算 来 实 现 的 其 一 般 形 式 为 : ( 类 型 说 明 符 ) ( 表 达 式 ) 14

15 其 功 能 是 把 表 达 式 的 运 算 结 果 强 制 转 换 成 类 型 说 明 符 所 表 示 的 类 型 在 使 用 强 制 转 换 时 应 注 意 以 下 问 题 : 类 型 说 明 符 和 表 达 式 都 必 须 加 括 号 ( 单 个 变 量 可 以 不 加 括 号 ), 如 把 (int)(x+y) 写 成 (int)x+y 则 成 了 把 x 转 换 成 int 型 之 后 再 与 y 相 加 了 无 论 是 强 制 转 换 或 是 自 动 转 换, 都 只 是 为 了 本 次 运 算 的 需 要 而 对 变 量 的 数 据 长 度 进 行 的 临 时 性 转 换, 而 不 改 变 数 据 说 明 时 对 该 变 量 定 义 的 类 型 例 如 :float(a+b) /* 将 表 达 式 a+b 的 结 果 转 换 成 单 精 度 型 */ (int)2.6*2 /* 表 达 式 的 值 是 4 而 不 是 5, 因 为 类 型 转 换 运 算 符 的 优 先 级 高 于 *, 因 此 先 进 行 (int)2.6 运 算, 把 2.6 转 换 为 整 数 2, 然 后 再 乘 以 2, 结 果 为 4 */ 1.3 语 句 1.C 语 言 的 种 类 C 语 句 可 分 为 以 下 5 类 : 表 达 式 语 句 : 由 表 达 式 加 上 分 号 ; 组 成 其 一 般 形 式 为 : 表 达 式 ; 执 行 表 达 式 语 句 就 是 计 算 表 达 式 的 值 赋 值 语 句 是 程 序 中 使 用 最 多 的 语 句 之 一, 是 由 赋 值 表 达 式 再 加 上 分 号 构 成 的 表 达 式 语 句 其 一 般 形 式 为 : 变 量 = 表 达 式 ; 在 赋 值 语 句 的 使 用 中 需 要 注 意 以 下 几 点 : 由 于 在 赋 值 符 = 右 边 的 表 达 式 也 可 以 又 是 一 个 赋 值 表 达 式, 因 此, 下 述 形 式 变 量 =( 变 量 = 表 达 式 ); 是 成 立 的, 从 而 形 成 嵌 套 的 情 形 其 展 开 之 后 的 一 般 形 式 为 : 变 量 = 变 量 = = 表 达 式 ; 注 意 在 变 量 说 明 中 给 变 量 赋 初 值 和 赋 值 语 句 的 区 别 给 变 量 赋 初 值 是 变 量 说 明 的 一 部 分, 赋 初 值 后 的 变 量 与 其 后 的 其 它 同 类 变 量 之 间 仍 必 须 用 逗 号 间 隔, 而 赋 值 语 句 则 必 须 用 分 号 结 尾 在 变 量 说 明 中, 不 允 许 连 续 给 多 个 变 量 赋 初 值, 而 赋 值 语 句 允 许 连 续 赋 值 注 意 赋 值 表 达 式 和 赋 值 语 句 的 区 别 赋 值 表 达 式 是 一 种 表 达 式, 它 可 以 出 现 在 任 何 允 许 表 达 式 出 现 的 地 方, 而 赋 值 语 句 则 不 能 函 数 调 用 语 句 : 由 函 数 名 实 际 参 数 加 上 分 号 ; 组 成 其 一 般 形 式 为 : 函 数 名 ( 实 际 参 数 表 ); 执 行 函 数 语 句 就 是 调 用 函 数 体 并 把 实 际 参 数 赋 予 函 数 定 义 中 的 形 式 参 数, 然 后 执 行 被 调 函 数 体 中 的 语 句 例 如 :printf( 低 碳 生 活!\n ); 控 制 语 句 : 控 制 语 句 用 于 控 制 程 序 的 流 程, 以 实 现 程 序 的 各 种 结 构 方 式 它 们 由 特 定 的 语 句 定 义 符 组 成 C 语 言 有 九 种 控 制 语 句 可 分 成 以 下 三 类 : 15

16 (1) 条 件 判 断 语 句 :if 语 句 switch 语 句 ; (2) 循 环 执 行 语 句 :do while 语 句 while 语 句 for 语 句 ; (3) 转 向 语 句 :break 语 句 goto 语 句 continue 语 句 return 语 句 复 合 语 句 : 把 多 个 语 句 用 括 号 括 起 来 组 成 的 一 个 语 句 称 复 合 语 句 在 程 序 中 应 把 复 合 语 句 看 成 是 单 条 语 句, 而 不 是 多 条 语 句 复 合 语 句 内 的 各 条 语 句 都 必 须 以 分 号 ; 结 尾, 在 括 号 外 不 能 加 分 号 空 语 句 : 只 有 分 号 ; 组 成 的 语 句 称 为 空 语 句 空 语 句 是 什 么 也 不 执 行 的 语 句 在 程 序 中 空 语 句 可 用 来 作 空 循 环 体 2. 程 序 的 基 本 结 构 1. 顺 序 结 构 顺 序 结 构 是 最 简 单 的 程 序 结 构, 它 是 由 若 干 个 依 次 执 行 的 处 理 步 骤 组 成 的 如 图 1-2 所 示,A 语 句 和 B 语 句 是 依 次 执 行 的, 只 有 在 执 行 完 A 语 句 后, 才 能 接 着 执 行 B 语 句 图 1-2 顺 序 结 构 [ 顺 序 结 构 案 例 ] 输 入 任 意 三 个 整 数, 求 它 们 的 和 及 平 均 值 /* 功 能 : 设 计 一 个 顺 序 结 构 程 序, 求 三 个 整 数 的 和 及 平 均 值 */ #include "stdio.h" int num1,num2,num3,sum; float aver; printf("please input three numbers:"); scanf("%d,%d,%d",&num1,&num2,&num3);/* 输 入 三 个 整 数 */ sum=num1+num2+num3; /* 求 累 计 和 */ aver=sum/3.0; /* 求 平 均 值 */ printf("num1=%d,num2=%d,num3=%d\n",num1,num2,num3); printf("sum=%d,aver=% 7.2f \n",sum,aver); 在 顺 序 结 构 程 序 中, 一 般 包 括 以 下 几 个 部 分 : 程 序 开 头 的 编 译 预 处 理 命 令 在 程 序 中 要 使 用 标 准 函 数 ( 又 称 库 函 数 ), 除 printf() 和 scanf() 外, 其 它 的 都 必 须 使 用 编 译 预 处 理 命 令, 将 相 应 的 头 文 件 包 含 进 来 顺 序 结 构 程 序 的 函 数 体 中, 是 完 成 具 体 功 能 的 各 个 语 句 和 运 算, 主 要 包 括 : a) 变 量 类 型 的 说 明 b) 提 供 数 据 语 句 c) 运 算 部 分 16

17 d) 输 出 部 分 2. 选 择 结 构 在 处 理 实 际 问 题 时, 只 有 顺 序 结 构 是 不 够 的, 经 常 会 遇 到 一 些 条 件 的 判 断, 流 程 根 据 条 件 是 否 成 立 有 不 同 的 流 向 如 图 1-3 所 示, 程 序 根 据 给 定 的 条 件 P 是 否 成 立 而 选 择 执 行 A 操 作 或 B 操 作 图 1-3 选 择 结 构 这 种 先 根 据 条 件 做 出 判 断, 再 决 定 执 行 哪 一 种 操 作 的 结 构 称 为 分 支 结 构, 也 称 为 选 择 结 构 [ 选 择 结 构 案 例 ] 求 一 元 二 次 方 程 ax2+bx+c=0 的 解 ( a 0 ) /* 功 能 : 求 一 元 二 次 方 程 的 解 */ #include "stdio.h" #include "math.h" float a,b,c,disc,x1,x2,p,q; scanf( %f,%f,%f, &a, &b, &c); disc=b*b-4*a*c; if (fabs(disc)<=1e-6) /*fabs() : 求 绝 对 值 库 函 数 */ printf( x1=x2=% 7.2f \n, -b/(2*a)); /* 输 出 两 个 相 等 的 实 根 */ else if (disc>1e-6) x1=(-b+sqrt(disc))/(2*a); /* 求 出 两 个 不 相 等 的 实 根 */ x2=(-b-sqrt(disc))/(2*a); printf("x1=% 7.2f,x2=% 7.2f \n", x1, x2); else p=-b/(2*a); /* 求 出 两 个 共 轭 复 根 */ q=sqrt(fabs(disc))/(2*a); printf( x1=% 7.2f + % 7.2f i\n, p, q); /* 输 出 两 个 共 轭 复 根 */ printf( x2=% 7.2f - % 7.2f i\n, p, q); 说 明 : 由 于 实 数 在 计 算 机 中 存 储 时, 经 常 会 有 一 些 微 小 误 差, 所 以 本 案 例 判 断 disc 是 否 为 0 的 方 法 是 : 判 断 disc 的 绝 对 值 是 否 小 于 一 个 很 小 的 数 17

18 3. 循 环 结 构 有 时 在 解 决 一 些 问 题 时, 经 常 需 要 重 复 执 行 一 些 操 作, 如 计 算 的 和, 我 们 可 以 利 用 循 环 结 构 控 制 程 序 按 照 一 定 的 条 件 或 者 次 数 重 复 执 行 需 要 重 复 执 行 同 一 操 作 的 结 构 称 为 循 环 结 构, 即 从 某 处 开 始, 按 照 一 定 条 件 反 复 执 行 某 一 处 理 步 骤, 反 复 执 行 的 处 理 步 骤 称 为 循 环 体 图 1-4 循 环 结 构 [ 循 环 结 构 案 例 1] 求 Fibonacci 数 列 的 前 40 个 数 该 数 列 的 生 成 方 法 为 :F1 =1,F2 =1, Fn =Fn-1 +Fn-2(n>=3), 即 从 第 3 个 数 开 始, 每 个 数 等 于 前 2 个 数 之 和 参 考 源 程 序 如 下 : #include "stdio.h" long int f1=1,f2=1; /* 定 义 并 初 始 化 数 列 的 头 2 个 数 */ int i=1; /* 定 义 并 初 始 化 循 环 控 制 变 量 i*/ for( ; i<=20; i++ ) /*1 组 2 个, 20 组 40 个 数 */ printf( %15ld%15ld, f1, f2); /* 输 出 当 前 的 2 个 数 */ if(i%2==0) printf( \n ); /* 输 出 2 次 ( 4 个 数 ), 换 行 */ f1 += f2; f2 += f1; /* 计 算 下 2 个 数 */ [ 循 环 结 构 案 例 2] 输 出 10 ~ 100 之 间 的 全 部 素 数 所 谓 素 数 n 是 指, 除 1 和 n 之 外, 不 能 被 2 ~(n-1) 之 间 的 任 何 整 数 整 除 算 法 设 计 要 点 : 显 然, 只 要 设 计 出 判 断 某 数 n 是 否 是 素 数 的 算 法, 外 面 再 套 一 个 for 循 环 即 可 判 断 某 数 n 是 否 是 素 数 的 算 法 : 根 据 素 数 的 定 义, 用 2~(n-1) 之 间 的 每 一 个 数 去 整 除 n, 如 果 都 不 能 被 整 除, 则 表 示 该 数 是 一 个 素 数 判 断 一 个 数 是 否 能 被 另 一 个 数 整 除, 可 通 过 判 断 它 们 整 除 的 余 数 是 否 为 0 来 实 现 参 考 源 程 序 如 下 : #include "stdio.h" int i=11, j, counter=0; 18

19 for( ; i<=100; i+=2) /* 外 循 环 : 为 内 循 环 提 供 一 个 整 数 i*/ for(j=2; j<=i-1; j++) /* 内 循 环 : 判 断 整 数 i 是 否 是 素 数 */ if(i%j= =0) /*i 不 是 素 数 */ break; /* 强 行 结 束 内 循 环, 执 行 下 面 的 if 语 句 */ if(counter%10= =0) /* 每 输 出 10 个 数 换 一 行 */ printf( \n ); if( j >= i ) /* 整 数 i 是 素 数 : 输 出, 计 数 器 加 1*/ printf( %6d,i); counter++; 3. if 语 句 if 语 句 构 成 的 选 择 结 构 1. if 语 句 的 三 种 形 式 第 一 种 形 式 为 基 本 形 式 :if if( 表 达 式 ) 语 句 其 语 义 是 : 如 果 表 达 式 的 值 为 真, 则 执 行 其 后 的 语 句, 否 则 不 执 行 该 语 句 第 二 种 形 式 为 : if-else if( 表 达 式 ) else 语 句 1; 语 句 2; 其 语 义 是 : 如 果 表 达 式 的 值 为 真, 则 执 行 语 句 1, 否 则 执 行 语 句 2 第 三 种 形 式 为 if-else-if 形 式 前 二 种 形 式 的 if 语 句 一 般 都 用 于 两 个 分 支 的 情 况 当 有 多 个 分 支 选 择 时, 可 采 用 if-else-if 语 句, 其 一 般 形 式 为 : if( 表 达 式 1) 语 句 1; else if( 表 达 式 2) 语 句 2; else if( 表 达 式 3) 语 句 3; else if( 表 达 式 m) else 语 句 m; 语 句 n; 其 语 义 是 : 依 次 判 断 表 达 式 的 值, 当 出 现 某 个 值 为 真 时, 则 执 行 其 对 应 的 语 句 然 后 跳 到 整 个 if 语 句 之 外 继 续 执 行 程 序 如 果 所 有 的 表 达 式 均 为 假, 则 执 行 语 句 n 然 后 继 续 执 行 后 续 程 序 2. 在 使 用 if 语 句 中 还 应 注 意 以 下 问 题 : 在 三 种 形 式 的 if 语 句 中, 在 if 关 键 字 之 后 均 为 表 达 式 该 表 达 式 通 常 是 逻 辑 表 19

20 达 式 或 关 系 表 达 式, 但 也 可 以 是 其 它 表 达 式, 如 赋 值 表 达 式 等, 甚 至 也 可 以 是 一 个 变 量 在 if 语 句 中, 条 件 判 断 表 达 式 必 须 用 括 号 括 起 来, 在 语 句 之 后 必 须 加 分 号 在 if 语 句 的 三 种 形 式 中, 所 有 的 语 句 应 为 单 个 语 句, 如 果 要 想 在 满 足 条 件 时 执 行 一 组 ( 多 个 ) 语 句, 则 必 须 把 这 一 组 语 句 用 括 起 来 组 成 一 个 复 合 语 句 但 要 注 意 的 是 在 之 后 不 能 再 加 分 号 if 语 句 的 嵌 套 或 者 为 当 if 语 句 中 的 执 行 语 句 又 是 if 语 句 时, 则 构 成 了 if 语 句 嵌 套 的 情 形 其 一 般 形 式 可 表 示 如 下 : if( 表 达 式 ) if 语 句 ; if( 表 达 式 ) else if 语 句 ; if 语 句 ; 在 嵌 套 内 的 if 语 句 可 能 又 是 if-else 型 的, 这 将 会 出 现 多 个 if 和 多 个 else 重 叠 的 情 况, 这 时 要 特 别 注 意 if 和 else 的 配 对 问 题 为 了 避 免 二 义 性,C 语 言 规 定,else 总 是 与 它 前 面 最 近 的 if 配 对 4. switch 语 句. C 语 言 还 提 供 一 种 用 于 多 分 支 选 择 的 switch 语 句, 其 一 般 形 式 为 : switch( 表 达 式 ) case 常 量 表 达 式 1: 语 句 1; case 常 量 表 达 式 2: 语 句 2; case 常 量 表 达 式 n: 语 句 n; default : 语 句 n+1; 其 语 义 是 : 计 算 表 达 式 的 值 并 逐 个 与 其 后 的 常 量 表 达 式 值 相 比 较, 当 表 达 式 的 值 与 某 个 常 量 表 达 式 的 值 相 等 时, 即 执 行 其 后 的 语 句, 然 后 不 再 进 行 判 断, 继 续 执 行 后 面 所 有 case 后 的 语 句 如 表 达 式 的 值 与 所 有 case 后 的 常 量 表 达 式 均 不 相 同 时, 则 执 行 default 后 的 语 句 在 使 用 switch 语 句 时 还 应 注 意 以 下 几 点 : 在 case 后 的 各 常 量 表 达 式 的 值 不 能 相 同, 否 则 会 出 现 错 误 在 case 后, 允 许 有 多 个 语 句, 可 以 不 用 括 起 来 各 case 和 default 子 句 的 先 后 顺 序 可 以 变 动, 而 不 会 影 响 程 序 执 行 结 果 default 子 句 可 以 省 略 不 用 5. while 和 do while 语 句 语 法 :while( 表 达 式 ) 语 句 ; 语 义 : 表 达 式 真 时 循 环 语 句 语 法 :do 语 句 ; while( 表 达 式 ); 20

21 语 义 : 执 行 语 句, 表 达 式 为 真 时 则 循 环 语 句 注 意 : 语 句 部 分 如 果 需 要 写 入 多 句 语 句 时 应 使 用 花 括 号, 表 示 只 有 一 句 语 句 循 环 应 该 趋 向 结 束 do while 语 句 首 先 执 行 语 句 一 次, 然 后 进 行 判 断,while 语 句 先 判 断, 真 则 执 行 语 句, 假 的 话 语 句 一 次 都 不 执 行 在 while 语 句 中, 循 环 语 句 后 有 分 号, 在 do while 中 while 语 句 后 有 分 号 6. for 语 句 语 法 : for( 表 达 式 1, 表 达 式 2, 表 达 式 3) 语 句 ; 语 义 :S1: 先 计 算 表 达 式 1 的 值 ; S2: 再 计 算 表 达 式 2 的 值, 真 则 循 环 语 句, 假 则 跳 出 ; S3: 计 算 表 达 式 3 的 值, 转 向 S2; 表 达 式 省 略 注 意 : 表 达 式 1 省 略, 跳 过 表 达 式 1; 省 略 表 达 式 2, 认 为 表 达 式 2 始 终 为 真 ; 表 达 式 3 可 以 省 略, 跳 过 表 达 式 3; 省 略 表 达 式 1 和 表 达 式 3, 等 同 WHILE 语 句 ; 省 略 3 个 表 达 式, 无 休 止 执 行 循 环 体 ; 表 达 式 1,3 可 以 与 循 环 控 制 无 关 的 任 意 表 达 式, 可 以 使 用 逗 号 表 达 式, 求 解 顺 序 ; 自 左 到 右 ; 例 如 : 一 个 计 算 程 序, 该 程 序 从 0 一 直 累 加 到 99, 最 后 输 出 累 加 和 不 省 略 表 达 式 1, 则 程 序 如 下 : int i,sum; /* I 是 累 加 器,sum 是 结 果 变 量 */ for(i=0,sum=0;i<100;i++) sum=sum+i; printf("%d",sum) 表 达 式 1 省 略, 则 程 序 如 下, 完 成 相 同 的 程 序 功 能 : int i=0,sum=0; for( ;i<100;i++) sum=sum+i; printf("%d",sum); 省 略 表 达 式 2, 则 程 序 如 下, 完 成 相 同 的 程 序 功 能 : int i=0,sum=0; for( ; ;i++) if (i<100) sum=sum+i; else break; printf("%d",sum); 这 里 请 大 家 注 意,break 是 跳 出 循 环 的 语 句, 没 有 break 程 序 会 进 入 死 循 环 这 是 同 学 们 应 该 予 以 避 免 的 省 略 表 达 式 3, 则 程 序 如 下, 完 成 相 同 的 程 序 功 能 : int i=0,sum=0; for( ; ; ) if (i<100) sum=sum+i;i++; else break; 21

22 printf("%d",sum); 7. 循 环 结 构 的 并 列 以 及 嵌 套 循 环 中 包 含 循 环 称 为 循 环 嵌 套 一 个 循 环 结 束 后 执 行 另 外 一 个 循 环 称 为 循 环 并 列 辨 析 如 程 序 : a) for(i=1;i<=3;i++) b)for(i=1;i<=3;i++); for(j=1;j<=2;j++) for(j=1;j<=2;j++) printf("*"); 6 次 printf("*"); 2 次 a 程 序 中 * 一 共 输 出 6 次, 而 b 程 序 * 一 共 输 出 2 次 程 序 a 中 两 个 for 语 句 相 互 关 系 为 嵌 套, 当 变 量 i 的 循 环 还 没 有 结 束 的 时 候, 变 量 j 的 循 环 就 开 始 了 程 序 2 中 第 一 个 for 语 句 for(i=1;i<=3;i++); 这 里 没 有 循 环 体, 先 把 I 的 循 环 结 束, 然 后 再 开 始 j 的 循 环, 属 于 并 列 循 环 关 系 该 内 容 是 C 语 言 考 试 考 查 的 重 点, 也 是 很 容 易 犯 错 误 的 地 方, 必 须 结 合 题 目 仔 细 体 会 运 行 程 序 的 代 码 执 行 先 后 次 序 8. 中 断 和 转 向 语 句 (1) break 语 法 :break; 语 义 : 跳 出 最 近 的 循 环 或 者 switch, 执 行 后 继 语 句 例 如 : int i,j; for(i=0;i<=9;i++) for(j=0;j<=9;j++) break; printf("*") 该 程 序 输 出 9 个 *,break 只 跳 出 j 的 循 环,i 的 循 环 继 续 进 行, 如 果 需 要 连 i 的 循 环 也 要 跳 出, 那 么 我 需 要 2 个 break, 一 个 break 跳 出 j 的 循 环, 另 一 个 break 跳 出 i 循 环 程 序 如 下 : int i,j; for(i=0;i<=9;i++) for(j=0;j<=9;j++) break;break; printf("*") (2) continue 语 法 :continue; 语 义 : 结 束 本 次 循 环, 转 入 下 次 循 环 的 的 判 断 和 语 句 执 行, 但 是 for 语 句 中 本 次 循 环 的 表 达 式 3 依 然 要 执 行 例 如 : a) b) int i=1; int i; while(i<3) for(i=1;i<3;i++) continue; continue; 22

23 i++; printf("%d",i); printf("%d",i); 程 序 a, 程 序 b 一 个 是 用 while 语 句 来 实 现, 一 个 是 用 for 语 句 来 实 现, 同 样 都 为 i<3 的 判 断 条 件, 都 是 i++ 的 累 加, 都 是 i=1 做 为 初 始 条 件, 但 是 程 序 a 是 死 循 环, 而 程 序 b 不 是 最 后 返 回 值 为 3 对 于 while 语 句 来 说 continue; 则 舍 弃 本 次 循 环 后 面 的 语 句, 直 接 进 行 表 达 式 判 断 对 于 for 语 句, 舍 弃 本 次 循 环 后 面 的 语 句, 但 是 累 加 作 用 的 表 达 式 3 依 然 要 执 行, 然 后 执 行 表 达 式 2 判 断 下 次 循 环 是 否 进 行 (3) return 语 法 :return; 语 义 : 跳 出 当 前 函 数, 如 果 当 前 函 数 是 main 函 数, 那 么, 直 接 结 束 程 序 1.4 输 入 输 出 格 式 C 语 言 本 身 不 提 供 输 入 输 出 操 作 语 句 C 程 序 中 的 输 入 和 输 出 操 作 是 依 靠 调 用 C 语 言 的 标 准 输 入 输 出 函 数 来 完 成 的 下 面 介 绍 最 常 用 的 四 个 标 准 输 入 输 出 函 数 :printf () 函 数 scanf () 函 数 putchar () 函 数 和 getchar () 函 数 格 式 输 入 函 数 scanf() 和 格 式 输 出 函 数 printf() 1. printf() 函 数 printf () 函 数 的 作 用 是 按 照 指 定 的 格 式 向 终 端 输 出 数 据 printf() 函 数 的 一 般 格 式 为 : printf( 格 式 控 制, 输 出 表 列 ) 其 中 : 格 式 控 制 又 称 格 式 控 制 字 符 串, 是 一 个 用 双 引 号 括 起 来 的 字 符 串, 它 包 含 以 下 三 类 字 符 : 普 通 字 符, 对 于 此 类 字 符, 将 按 原 样 输 出 转 义 符, 它 由 反 斜 杠 字 符 \ 后 跟 一 个 特 定 字 符 组 成, 用 来 输 出 转 义 符 所 代 表 的 控 制 代 码 或 特 殊 字 符, 表 1-2 列 出 了 常 用 的 转 义 符 : 表 1-2 格 式 转 义 字 符 字 符 形 式 功 能 \n 换 行 \t 横 向 跳 格 \v 竖 向 跳 格 \b 退 格 \r 回 车 \ 双 引 号 字 符 \ 单 引 号 ( 撇 号 ) 字 符 \\ 反 斜 杠 字 符 \ 23

24 \ddd 1 到 3 位 8 进 制 数 所 代 表 的 字 符 \xhh 1 到 2 位 16 进 制 数 所 代 表 的 字 符 格 式 符, 它 是 由 百 分 字 符 % 后 跟 格 式 字 符 组 成, 格 式 指 定 了 相 对 应 的 输 出 项 数 值 的 输 出 类 型 及 格 式 表 1-3 列 出 了 printf () 中 常 用 的 格 式 字 符 输 出 表 列 可 以 是 合 法 的 常 量 变 量 和 表 达 式, 各 输 出 项 之 间 要 用 逗 号 分 开 如 :printf ( %d,%c\n,a,c); 可 输 出 整 型 变 量 a 的 值 和 字 符 型 变 量 c 的 值 表 1-3 常 用 的 printf ( ) 格 式 字 符 字 符 形 式 c d 输 出 单 个 字 符 输 出 带 符 号 的 十 进 制 整 数 说 明 o x u s 以 八 进 制 无 符 号 形 式 输 出 整 数 以 十 六 进 制 无 符 号 形 式 输 出 整 数 输 出 无 符 号 的 十 进 制 整 数 输 出 字 符 串 F( 或 lf) 以 小 数 形 式 输 出 单 精 度 数 ( 或 双 精 度 数 ) E( 或 le) 以 指 数 形 式 输 出 单 精 度 数 ( 或 双 精 度 数 ) 另 外, 还 可 以 在 % 与 格 式 符 号 之 间 增 加 m.[n] 以 指 定 输 出 宽 度,m 指 出 数 据 宽 度,n 对 于 实 数, 表 示 输 出 n 位 小 数,n 对 于 字 符 串, 表 示 截 取 的 字 符 个 数 输 出 数 据 采 用 右 对 齐 形 式 若 欲 指 定 输 出 宽 度 域 的 同 时 还 指 定 数 据 按 左 对 齐 形 式, 则 可 在 宽 度 域 前 加 上 一 个 减 号 符 - 来 实 现 如 格 式 符 %-m.nf 2. scanf() 函 数 scanf () 函 数 的 作 用 是 把 从 终 端 ( 如 键 盘 ) 上 输 入 的 数 据 传 送 给 对 应 的 变 量 scanf () 函 数 的 一 般 格 式 为 : scanf ( 格 式 控 制, 输 入 项 地 址 表 ) 其 中 : 格 式 控 制 的 含 义 与 printf () 函 数 基 本 相 同 输 入 项 地 址 表 可 包 含 若 干 个 有 待 输 入 其 相 应 值 的 变 量 的 内 存 单 元 地 址, 各 个 地 址 项 之 间 用 逗 号 隔 开 C 语 言 中 的 地 址 量 的 表 示 是 在 变 量 前 加 前 缀 字 符 & 表 1-4 列 出 了 scanf () 函 数 中 常 用 的 格 式 字 符 表 1-4 常 用 的 scanf () 函 数 格 式 字 符 格 式 字 符 c d o x s 功 能 输 入 单 个 字 符 输 入 带 符 号 的 十 进 制 整 数 以 八 进 制 无 符 号 形 式 输 入 整 数 以 十 六 进 制 无 符 号 形 式 输 入 整 数 输 入 字 符 串 f 以 小 数 形 式 输 入 单 精 度 数 ( 或 双 精 度 数 ) e 以 指 数 形 式 输 入 单 精 度 数 ( 或 双 精 度 数 ) u l 输 入 无 符 号 的 十 进 制 整 数 输 入 长 整 型 数 据 以 及 double 型 数 据 24

25 1.4.2 字 符 输 入 函 数 getchar() 和 字 符 输 出 函 数 putchar() 1.putchar() 函 数 putchar() 函 数 的 作 用 是 把 一 个 字 符 输 出 到 标 准 输 出 设 备 ( 如 显 示 器 打 印 机 ) 上 putchar() 函 数 的 一 般 格 式 为 : putchar( 变 量 名 ) 其 中 变 量 名 可 以 是 一 个 字 符 变 量 或 一 个 整 型 变 量 2.getchar( ) 函 数 getchar () 函 数 的 作 用 是 从 标 准 输 入 设 备 ( 如 键 盘 ) 上 输 入 一 个 字 符 getchar () 函 数 的 一 般 格 式 为 : getchar ( ) ; getchar () 函 数 本 身 没 有 参 数, 其 函 数 值 就 是 从 输 入 设 备 得 到 的 字 符 注 意 : 在 调 用 putchar () 或 getchar () 函 数 的 程 序 开 头 一 定 要 使 用 文 件 包 含 命 令 : # include <stdio.h> 3. 文 件 包 含 命 令 文 件 包 含 预 处 理 命 令 的 作 用 是 使 一 个 源 文 件 将 另 一 个 源 文 件 的 全 部 内 容 包 含 进 来, 其 一 般 形 式 为 : # include < 文 件 名.h> 或 # include 文 件 名.h 说 明 : (1) 文 件 名 应 是 C 语 言 的 源 文 件 名 该 源 文 件 可 以 是 系 统 提 供 的, 也 可 以 是 用 户 编 写 的 通 常 称 为 头 文 件, 习 惯 用 字 母 h 作 为 后 缀 如 : # include <stdio.h> 或 # include stdio.h (2) 两 种 形 式 的 区 别 : 当 文 件 名 用 尖 括 号 括 起 来 时, 系 统 到 存 放 C 库 函 数 头 文 件 所 在 的 目 录 中 寻 找 要 包 含 的 文 件, 这 称 为 标 准 方 式 ; 而 文 件 名 用 双 引 号 括 起 来 时, 系 统 先 在 用 户 当 前 目 录 中 寻 找 要 包 含 的 文 件, 如 果 找 不 到, 再 按 标 准 方 式 查 找 (3) 一 个 include 命 令 只 能 指 定 一 个 被 包 含 的 文 件 4.getch() getche() getchar() 三 个 函 数 在 使 用 上 的 区 别 这 三 个 函 数 都 是 无 参 函 数, 其 功 能 是 从 键 盘 读 入 一 个 字 符 getch() 和 getche() 函 数 的 区 别 是 getch() 函 数 不 把 读 入 的 字 符 回 显 到 屏 幕 上, 而 getche() 函 数 却 将 读 入 的 字 符 回 显 到 屏 幕 上 getchar() 函 数 也 是 从 键 盘 上 读 入 一 个 字 符, 并 带 回 显, 它 与 前 面 两 个 函 数 的 区 别 在 于 :getchar() 函 数 等 待 输 入 直 到 按 回 车 才 结 束, 回 车 前 的 所 有 输 入 字 符 都 会 逐 个 显 示 在 屏 幕 上, 但 只 有 第 一 个 字 符 作 为 函 数 的 返 回 值 例 : #include<stdio.h> char c; c=getchar(); /* 从 键 盘 读 入 字 符 直 到 回 车 结 束 */ putchar(c); /* 显 示 输 入 的 第 一 个 字 符 */ getch(); /* 等 待 按 任 一 健 */ 25

26 1.5 典 型 案 例 分 析 1. 什 么 是 表 达 式? [ 分 析 ] C 语 言 提 供 了 丰 富 的 运 算 符, 因 此 组 成 的 表 达 式 种 类 也 很 多 常 见 的 表 达 式 有 以 下 6 种 : (1) 算 术 表 达 式 如,x + 1.0/y - z%5 (2) 关 系 表 达 式 如,x > y + z( 逻 辑 值 :0 或 1) (3) 逻 辑 表 达 式 如,x > y && x < z( 逻 辑 值 0 或 1) (4) 赋 值 表 达 式 如,x = ( y = z + 5 ) (5) 条 件 表 达 式 如,x > y? x : y (6) 逗 号 表 达 式 如,x = 1, y ++, z += 2 在 表 达 式 书 写 与 使 用 过 程 中, 有 以 下 几 点 提 请 读 者 注 意 : 1 在 表 达 式 中 如 果 连 续 出 现 两 个 运 算 符, 为 避 免 二 义 性, 中 间 最 好 加 空 格 符 例 如, 表 达 式 x+++y 到 底 是 (x++)+y 还 是 x+(++y) 呢? 编 译 系 统 是 按 尽 量 取 大 的 原 则 来 分 割 连 续 多 个 运 算 符 因 此, 表 达 式 x+++y 被 认 为 是 (x++)+y 如 果 要 表 达 x 加 上 增 1 后 的 y, 应 写 成 x+(++y), 或 写 成 x+ ++y 即 中 间 加 一 个 空 格 分 隔 两 个 连 续 的 运 算 符 2 在 表 达 式 中, 加 圆 括 号 可 以 强 制 改 变 运 算 符 的 优 先 级 例 如, 表 达 式 (x+y)*z, 使 加 法 优 先 于 乘 法 3 优 先 级 用 来 说 明 表 达 式 的 计 算 顺 序 即 优 先 级 高 的 先 运 算, 优 先 级 低 的 后 运 算, 优 先 级 相 同 时 由 结 合 性 决 定 计 算 顺 序 2. 在 计 算 机 中 数 据 是 如 何 存 储 的? [ 分 析 ] 在 计 算 机 中 数 据 一 律 使 用 它 的 补 码 形 式 存 放 若 x 是 一 个 正 整 数, 则 它 的 补 码 是 本 身, 而 -x 的 补 码 表 示 是 用 x 的 反 码 加 上 1 用 补 码 表 示 负 整 数 是 为 了 简 化 整 数 的 运 算 3. 程 序 实 际 接 受 的 浮 点 数 与 书 写 的 浮 点 数 会 有 误 差? [ 分 析 ] 有 的 例 如,float x = f; 因 x 只 能 存 储 约 7 位 有 效 数 字, 浮 点 数 所 对 应 的 二 进 制 形 式 中, 超 出 存 储 位 数 的 那 些 位 不 会 被 存 储 变 量 x 中 存 储 的 浮 点 数 可 能 不 足 而 代 码 double y = , 在 变 量 y 中 存 储 的 浮 点 数 可 能 会 略 大 于 可 以 对 负 数 进 行 求 余 运 算 吗? [ 分 析 ] 答 案 是 肯 定 的 如 果 操 作 数 中 有 负 值, 求 余 的 原 则 为 : 先 取 绝 对 值 求 余, 余 数 取 与 被 除 数 相 同 的 符 号 例 如 :-10%3 的 结 果 为 -1;10%-3 的 结 果 为 1 进 行 求 余 运 算 时 应 注 意 : 操 作 数 必 须 是 整 型 数, 如 果 是 非 整 型 数, 必 须 将 操 作 数 强 制 转 换 成 整 型, 再 进 行 求 余 运 算, 否 则 将 出 现 编 译 错 误 5. 以 下 叙 述 正 确 的 是 A. C 语 言 比 其 他 语 言 高 级 B. C 语 言 可 以 不 用 编 译 就 能 被 计 算 机 识 别 执 行 C. C 语 言 以 接 近 英 语 国 家 的 自 然 语 言 和 数 学 语 言 作 为 语 言 的 表 达 形 式 D. C 语 言 出 现 最 晚 具 有 其 他 语 言 的 一 切 优 点 分 析 本 题 考 核 的 知 识 点 是 C 语 言 的 特 点 C 语 言 是 一 种 高 级 语 言, 必 须 编 译 成 目 标 26

27 代 码 才 能 执 行, 故 选 项 B 错 误 ; 与 其 他 语 言 相 比 C 语 言 更 接 近 于 硬 件, 更 低 级 ; 程 序 语 言 是 不 断 发 展 的, 不 断 有 新 的 语 言 出 现,C 语 言 不 是 出 现 最 晚 的, 故 选 项 A 和 选 项 D 错 误 ; 高 级 语 言 类 似 于 人 类 的 自 然 语 言 和 数 学 语 言 因 此 本 题 答 案 为 C 6. 在 一 个 C 语 言 程 序 中 A. 函 数 必 须 出 现 在 所 有 函 数 之 前 B. 函 数 可 以 在 任 何 地 方 出 现 C. 函 数 必 须 出 现 在 所 有 函 数 之 后 D. 函 数 必 须 出 现 在 固 定 位 置 分 析 本 题 考 核 的 知 识 点 是 函 数 的 位 置 C 语 言 规 定, 函 数 在 程 序 中 的 位 置 是 任 意 的, 可 以 在 程 序 的 前 部 中 部 或 后 部 因 此 本 题 答 案 为 B 7. 以 下 叙 述 正 确 的 是 A. C 程 序 中 注 释 部 分 可 以 出 现 在 程 序 中 任 何 合 适 的 地 方 B. 花 括 号 和 只 能 作 为 函 数 体 的 定 界 符 C. 构 成 C 程 序 的 基 本 单 位 是 函 数, 所 有 函 数 名 都 可 以 由 用 户 命 名 D. 分 号 是 C 语 句 之 间 的 分 隔 符, 不 是 语 句 的 一 部 分 分 析 本 题 考 核 的 知 识 点 是 C 语 言 函 数 语 句 的 概 念 注 释 以 及 C 程 序 的 基 本 结 构 花 括 号 和 不 仅 可 以 作 为 函 数 体 的 定 界 符, 而 且 可 以 作 为 复 合 语 句 的 定 界 符, 选 项 B 错 误 ; 函 数 不 可 以 由 用 户 命 名, 选 项 C 错 误 ; 分 号 是 C 语 句 的 结 束 符, 是 构 成 C 语 句 的 必 要 组 成 部 分, 选 项 D 错 误 ; 在 C 语 言 中, 允 许 在 任 何 能 够 插 入 空 格 符 的 位 置 插 入 注 释, 但 C 语 言 的 注 释 不 能 进 行 嵌 套, 因 此 本 题 答 案 为 A 8. 以 下 叙 述 正 确 的 是 A. C 语 言 的 源 程 序 不 必 通 过 编 译 就 可 以 直 接 运 行 B. C 语 言 中 的 每 条 可 执 行 语 句 最 终 都 将 被 转 换 成 二 进 制 的 机 器 指 令 C. C 源 程 序 经 编 译 形 成 的 二 进 制 代 码 可 以 直 接 运 行 D. C 语 言 中 的 函 数 不 可 以 单 独 进 行 编 译 分 析 本 题 考 核 的 知 识 点 是 C 程 序 从 编 写 到 生 成 可 执 行 文 件 的 步 骤 C 语 言 编 写 的 程 序 必 须 经 过 编 译 连 接 后 才 可 以 执 行, 选 项 A 错 误 ;C 语 言 编 译 后 生 成 的 二 进 制 代 码 是 目 标 文 件, 需 要 进 一 步 连 接 生 成.exe 文 件 方 可 执 行, 选 项 C 错 误 ;C 语 言 中 函 数 可 以 单 独 编 译 因 此 本 题 答 案 为 B 9. 以 下 叙 述 错 误 的 是 A. C 语 句 必 须 以 分 号 结 束 B. 复 合 语 句 在 语 法 上 被 看 作 一 条 语 句 C. 空 语 句 出 现 在 任 何 位 置 都 不 会 影 响 程 序 运 行 D. 赋 值 表 达 式 末 尾 加 分 号 就 构 成 赋 值 语 句 分 析 本 题 考 核 的 知 识 点 是 C 语 言 中 语 句 的 概 念 C 语 句 必 须 以 分 号 结 束, 选 项 A 正 确 ; 复 合 语 句 在 语 法 上 被 看 作 一 条 语 句, 选 项 B 正 确 ; 空 语 句 也 算 是 一 条 语 句, 因 此 如 果 空 语 句 出 现 在 条 件 或 者 循 环 语 句 中, 一 样 会 被 当 作 条 件 子 句 或 者 循 环 体 来 看 待, 所 以 选 项 C 是 错 误 的 ; 赋 值 表 达 式 末 尾 加 分 号 就 构 成 赋 值 语 句, 因 此 本 题 答 案 为 C 10. 以 下 叙 述 正 确 的 是 A. C 程 序 的 执 行 是 从 函 数 开 始, 到 本 程 序 的 最 后 一 个 函 数 结 束 B. C 程 序 的 执 行 是 从 第 一 个 函 数 开 始, 到 本 程 序 的 最 后 一 个 函 数 结 束 C. C 程 序 的 执 行 是 从 函 数 开 始, 到 本 程 序 的 函 数 结 束 27

28 D. C 程 序 的 执 行 是 从 第 一 个 函 数 开 始, 到 本 程 序 的 函 数 结 束 分 析 本 题 考 核 的 知 识 点 是 C 程 序 的 执 行 过 程 任 何 一 个 C 程 序 都 是 从 函 数 开 始 执 行 的 在 函 数 中 用 户 根 据 实 际 需 要 调 用 其 他 函 数, 这 些 函 数 执 行 完 毕 后 将 返 回 到 函 数 当 执 行 完 函 数 的 最 后 一 个 语 句 后, 整 个 程 序 运 行 结 束 因 此 本 题 答 案 为 C 11. 下 列 选 项 中 不 属 于 算 法 特 性 的 是 A. 确 定 性 B. 可 行 性 C. 有 输 出 D. 无 穷 性 分 析 本 题 考 核 的 知 识 点 是 算 法 的 特 性 一 个 算 法 必 须 具 有 五 个 特 性, 即 有 输 入 有 输 出 有 穷 性 确 定 性 和 可 行 性 其 中 有 穷 性 是 指 算 法 必 须 总 是 在 执 行 完 有 穷 步 之 后 结 束, 而 且 每 步 都 在 有 穷 时 间 内 完 成 D 选 项 不 是 算 法 的 特 性 因 此 本 题 答 案 为 D 12. 结 构 化 程 序 设 计 主 要 强 调 的 是 A. 程 序 的 规 模 B. 程 序 的 易 读 性 C. 程 序 的 执 行 效 率 D. 程 序 的 可 移 植 性 分 析 本 题 考 核 的 知 识 点 是 结 构 化 程 序 设 计 的 优 点 按 结 构 化 程 序 设 计 方 法 设 计 出 的 程 序 易 于 理 解 使 用 和 维 护, 便 于 控 制 降 低 程 序 的 复 杂 性, 便 于 验 证 程 序 的 正 确 性, 程 序 清 晰 易 读, 可 理 解 性 好 因 此 本 题 答 案 为 B 13. 结 构 化 程 序 设 计 的 一 种 基 本 方 法 是 A. 筛 选 法 B. 递 归 法 C. 归 纳 法 D. 逐 步 求 精 法 分 析 本 题 考 核 的 知 识 点 是 结 构 化 程 序 设 计 的 方 法 在 结 构 化 程 序 设 计 中 通 常 采 取 自 上 而 下 逐 步 求 精 的 方 法, 其 总 的 思 想 是 先 全 局 后 局 部 先 整 体 后 细 节 先 抽 象 后 具 体 而 筛 选 法 递 归 法 和 归 纳 法 指 的 都 是 程 序 的 某 种 具 体 算 法 因 此 本 题 答 案 为 D 14. 结 构 化 程 序 有 三 种 基 本 结 构 组 成, 三 种 基 本 结 构 组 成 的 算 法 A. 可 以 完 成 任 何 复 杂 的 任 务 B. 只 能 完 成 部 分 复 杂 的 任 务 C. 只 能 完 成 符 合 结 构 化 的 任 务 D. 只 能 完 成 一 些 简 单 的 任 务 分 析 本 题 考 核 的 知 识 点 是 结 构 化 程 序 的 基 本 结 构 的 概 念 结 构 化 程 序 的 三 种 基 本 结 构 是 顺 序 循 环 选 择, 任 何 复 杂 的 任 务 都 可 以 通 过 这 三 种 结 构 来 实 现 因 此 本 题 答 案 为 A 15. 以 下 叙 述 正 确 的 是 A. 用 C 程 序 实 现 的 算 法 必 须 要 有 输 入 和 输 出 操 作 B. 用 C 程 序 实 现 的 算 法 可 以 没 有 输 出 但 必 须 要 有 输 入 C. 用 C 程 序 实 现 的 算 法 可 以 没 有 输 入 但 必 须 要 有 输 出 D. 用 C 程 序 实 现 的 算 法 可 以 既 没 有 输 入 也 没 有 输 出 分 析 本 题 考 核 的 知 识 点 是 C 语 言 中 算 法 的 特 性 一 个 算 法 应 当 有 零 个 或 多 个 输 入, 有 一 个 或 多 个 输 出 因 此 本 题 答 案 为 C 16. 在 C 语 言 中, 要 求 运 算 数 必 须 是 整 型 的 运 算 符 是 A./ B ++ C.! = D.% 分 析 求 余 运 算 符 ( 模 运 算 符 ) % 为 双 目 运 算, 具 有 左 结 合 性, 而 且 要 求 参 与 运 算 的 数 据 均 为 整 型, 求 余 运 算 的 结 果 等 于 两 数 相 除 后 的 余 数 因 此 本 题 答 案 为 D 17. 定 义 x 和 y 为 double 型 变 量, 则 表 达 式 x=10,y=x+3/2 的 值 为 A.10 B.20 C.11.5 D.11.0 分 析 这 是 一 个 逗 号 表 达 式, 该 表 达 式 的 值 就 是 y=x+3/2 的 值 由 于 3/2 是 两 个 整 数 相 除, 得 到 的 结 果 应 为 整 数 1, 即 : 该 表 达 式 相 当 于 y=x+1, 而 y 是 double 型 的, 因 此,y 的 值 为 11.0 于 是, 正 确 答 案 是 D 28

29 18. 运 行 下 列 程 序, 其 输 出 结 果 为 # include <stdio.h> main ( ) int a=2 ; a%=4-1 ; printf ( % d,, a) ; a + = a * = a - = a * = 3 ; printf (" % d ", a ) ; A.2,0 B.1, 0 C.-1, 12 D.2, 12 分 析 因 为 % = 运 算 的 优 先 级 别 低 于 - 运 算,a%=4-1 即 是 a% =3, 等 价 于 a = a %3=2%3 = 2, 可 见, 选 项 B 和 选 项 C 都 是 错 误 的 正 确 的 只 能 是 选 项 A 或 选 项 D 尽 管 表 达 式 a + = a * = a - = a * = 3 表 面 上 很 复 杂, 计 算 时 只 要 注 意 到 赋 值 类 表 达 式 的 值 和 变 量 值 随 时 被 更 新, 就 很 容 易 计 算 出 正 确 的 结 果 根 据 赋 值 类 运 算 符 自 右 至 左 的 结 合 性, 将 其 展 开 计 算 开 始 时,a=2, 表 达 式 a * = 3 使 得 a 值 为 6, 于 是, 表 达 式 a - = a * = 3 相 当 于 a - = 6, 使 得 a = a 6 = 6 6 = 0. 至 此, 后 面 的 表 达 式 已 不 必 继 续 计 算, 最 终 a = 0 正 确 答 案 为 A 19. 运 行 下 列 程 序, 其 输 出 结 果 为 #include<stdio.h> main ( ) int a ; char c=10 ; float f=100.0 ; double x ; a=f/=c*= ( x=6.5); printf ( %d %d %3.1f %3.1f \n, a, c, f, x ) ; A B C D 分 析 本 程 序 的 执 行 顺 序 如 下 : (1)x=6.5, x 的 值 为 6.5 ; (2)c*=x,c 的 值 为 65; (3)f/=c, 即 f=f/c,f 值 为 1.538; (4)a=f, 因 为 a 是 整 型 变 量, 故 只 存 储 f 值 的 整 数 部 分 1, 输 出 f 值 时, 因 限 定 其 值 域 宽 为 3, 小 数 位 为 1, 故 输 出 1.5 正 确 答 案 为 B 20. 若 有 定 义 :double a ; 则 正 确 的 语 句 为 A.scanf ( % lf, a ) ; B.scanf ( %f, &a) ; C.scanf ( % 5.2f, &a) D.scanf ( %le, &a) ; 分 析 选 项 A 错, 因 为 scanf 中 要 求 给 出 变 量 地 址, 如 给 出 变 量 名 则 会 出 错, 应 改 为 scnaf("%d",&a); 才 是 合 法 的 选 项 B 错, 因 为 double 型 应 用 %lf 或 %le 格 式 选 项 C 错, 因 为 scanf 函 数 中 没 有 精 度 控 制, 不 能 企 图 用 此 语 句 输 入 小 数 为 2 位 的 实 数 正 确 答 案 为 D 21. 运 行 下 列 程 序, 其 输 出 结 果 为 29

30 #include <stdio.h> 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) ; A.a=2,b=1 B.a=1,b=1 C.a=1,b=0 D.a=2,b=2 分 析 在 该 题 中, 当 执 行 完 case 1 后 边 的 语 句 序 列 后, 接 着 继 续 执 行 case 2 注 意 case 后 边 的 语 句 序 列 中 不 管 有 多 少 条 语 句, 都 可 以 不 加, 这 是 与 if 语 句 不 同 的 因 此 程 序 中 a++ 被 执 行 两 次,b++ 被 执 行 一 次, 所 以,a 和 b 的 值 分 别 为 2 和 1 因 此 本 题 的 正 确 答 案 为 A 22. 运 行 下 列 程 序, 其 输 出 结 果 为 #include <stdio.h> main( ) int a=2,b=-1,c=2; if (a<b) if (b<0) c=0; else c++; printf( %d, c); A.0 B.1 C.2 D.3 分 析 从 书 写 形 式 上, 似 乎 else 应 与 第 一 个 if 配 对, 但 根 据 C 语 言 的 规 定,else 应 与 前 面 离 它 最 近 的 未 配 对 的 if 配 对, 本 程 序 中 的 else 与 第 二 个 if 配 对 第 一 个 if 中, 由 于 a<b 不 成 立, 直 接 执 行 else 后 的 printf( %d, c), 输 出 c 的 值, 所 以 本 程 序 的 输 出 结 果 是 2 因 此 本 题 的 正 确 答 案 为 C 23. 若 x y z 均 已 正 确 定 义, 且 x=1,y=2,z=3, 则 执 行 以 下 if 语 句 后,x y z 中 的 值 分 别 是 多 少? if(x>z) y=x ;x=z ;z=y; 分 析 for 循 环 语 句 的 一 般 格 式 是 :for ( 表 达 式 1; 表 达 式 2; 表 达 式 3) 语 句 ; 语 句 如 果 是 复 合 语 句, 需 要 用, 而 本 题 中 的 语 句 只 有 1 句, 即 y=x; 根 据 给 定 的 x 和 z 的 初 值, 可 知 (x>z) 为 假, 因 此 执 行 后 面 的 语 句 x=z;z=y; 因 此 x y z 的 值 分 别 是 :3,2,2 24. while 循 环 和 do-while 循 环 有 什 么 不 同? [ 分 析 ] do-while 循 环 与 while 循 环 的 最 根 本 的 区 别 是 :do-while 循 环 在 判 断 条 件 是 否 成 立 前, 先 执 行 循 环 体 语 句 一 次, 所 以 无 论 条 件 成 立 与 否 循 环 体 都 至 少 执 行 过 一 次 而 while 循 环 则 是 先 判 断 条 件 是 否 成 立, 若 成 立 才 能 继 续 执 行 循 环 体 内 的 语 句 程 序 1: 30

31 int a=0; while(a<0) a++; printf("%d",a); 程 序 2: int a=0; do a++; while(a<0) ; printf("%d",a); 程 序 1 输 出 的 结 果 是 0, 说 明 while 循 环 先 对 条 件 表 达 式 进 行 了 判 断, 由 于 表 达 式 为 假, 所 以 循 环 体 没 有 被 执 行 程 序 2 的 输 出 结 果 是 1, 说 明 do-while 循 环 先 执 行 了 循 环 体, 再 判 断 条 件 表 达 式, 由 于 表 达 式 为 假, 循 环 结 束, 循 环 体 被 执 行 了 一 次 25. break 语 句 与 continue 语 句 的 区 别 是 什 么? [ 分 析 ] 在 switch 语 句 中,break 语 句 可 用 于 case 分 支 的 后 面, 用 于 执 行 完 某 个 分 支 后 跳 出 switch 语 句 而 continue 语 句 不 能 用 于 switch 结 构 中 在 循 环 语 句 中,break 语 句 用 于 结 束 循 环 当 有 循 环 嵌 套 时,break 语 句 只 能 跳 出 本 层 循 环, 并 不 能 使 多 重 循 环 全 部 结 束 continue 语 句 的 作 用 是 : 提 前 结 束 本 次 循 环 体 的 执 行, 接 着 进 行 下 一 次 循 环 条 件 的 判 断 26. 为 什 么 运 行 下 面 程 序 时 屏 幕 上 没 有 输 出 结 果 且 不 能 返 回 到 Turbo C 的 集 成 环 境 中? int i=1; while(i=2) i++; printf("%d",i++); [ 分 析 ] 此 题 本 意 是 比 较 i 是 否 等 于 2, 若 等 于 则 循 环 继 续 但 程 序 中 误 将 条 件 表 达 式 的 比 较 运 算 符 == 写 成 了 赋 值 运 算 符 =, 所 以 i 的 值 始 终 为 2, 所 以 条 件 表 达 式 的 值 始 终 为 真, 循 环 无 法 结 束, 出 现 死 循 环 此 时 可 以 同 时 按 Ctrl 和 Break 键 强 制 中 断 程 序 执 行, 返 回 编 辑 环 境 27. 运 行 下 列 程 序, 其 输 出 结 果 为 #include <stdio.h> int i=1,j=1; 31

32 for (; j<10;j++) if (j>5) break; if (j%2!=0) j+=3; j-=1; continue; printf( d,%d,i,j); 分 析 使 用 for 循 环 时, 表 达 式 1 可 以 省 略, 因 为 在 此 语 句 之 前 已 经 给 循 环 变 量 赋 初 值, 即 j=1;j%2!=0 为 真, 执 行 j+=3, 则 j=4, 遇 到 continue 重 新 执 行 循 环 体 ( 需 执 行 for 循 环 的 表 达 式 3, 即 j++, 得 j=5); j=5,j%2!=0 为 真, 执 行 j+=3, 得 j=8, 遇 到 continue 重 新 执 行 循 环 体 ( 需 执 行 for 循 环 的 表 达 式 3, 即 j++, 得 j=9); j=9, 因 为 j>5, 退 出 for 循 环, 因 此 本 题 的 正 确 答 案 为 :1,9 28. 运 行 下 列 程 序, 其 输 出 结 果 为 #include <stdio.h> int k=0,m=0; int i,j; for(i=0;i<2;i++) m=i+j; for (j=0;j<3;j++) k++; k-=j; printf( k=%d,m=%d,k,m); A.k=0,m=3 B.k=0,m=5 C.k=1,m=3 D.k=1,m=5 分 析 本 题 考 查 一 个 二 重 循 环 结 构 只 要 留 意 在 一 个 循 环 中 止 时 循 环 控 制 变 量 的 变 化 即 可 很 明 显, 外 层 循 环 执 行 两 次 这 两 次 执 行 循 环 的 情 形 如 下 : 在 i=0 时, 内 循 环 执 行 3 次 (j=0,1,2), 直 到 j=3 时 中 止 由 于 每 次 内 层 循 环 均 使 k 加 1, 故 循 环 结 束 时 k=3 再 执 行 k- =j;, 在 i=1 时, 内 层 循 环 仍 然 执 行 原 操 作, 使 j=3,k=0 现 在, 计 算 表 达 式 i=2, 表 达 式 i<2 为 假, 外 层 循 环 结 束, 执 行 m=i+j=2+3=5 因 此 本 题 的 正 确 答 案 是 B 29. 运 行 下 列 程 序, 其 输 出 结 果 为 # include <stdio.h> int i,s=0; for (i=1;i<=100;i++) if (i%2==0) continue; s+=i; 32

33 printf( s=%d\n,s); 分 析 continue 语 句 只 能 用 于 循 环 语 句 中, 作 用 为 结 束 本 次 循 环, 即 跳 过 循 环 体 中 尚 未 执 行 的 语 句, 接 着 进 行 是 否 执 行 下 一 次 循 环 的 判 定 在 本 题 的 循 环 体 中, 当 i 为 偶 数 时 不 执 行 s+=i 语 句, 直 接 进 行 下 一 次 循 环, 最 后 的 s= =2500 所 以 本 题 答 案 为 : 试 用 do-while 语 句 实 现 下 列 程 序 段 的 功 能, 其 代 码 为 : for( n=1;n<=10;n++) if( n%3==0) continue; printf( %d, n); 分 析 本 题 知 识 点 则 是 :do-while 语 句 for 语 句 语 意 语 法 ;do-while 语 句 只 有 一 个 表 达 式 用 于 循 环 控 制 ( 即 :for 语 句 的 表 达 式 2), 循 环 控 制 变 量 的 赋 初 值 必 须 放 在 do-while 语 句 前 ( 即 :for 语 句 的 表 达 式 1), 循 环 控 制 变 量 的 渐 变 应 放 在 循 环 体 内 ( 即 :for 语 句 的 表 达 式 3) n=1; do if( n%3==0) continue; printf( %d, n++); while(n<=10) ; 31. 直 到 型 循 环 语 句 是 分 析 本 题 知 识 点 则 是 : 循 环 语 句 分 类,C 语 言 提 供 了 三 种 循 环 语 句, 其 中 while 语 句 for 语 句 是 当 型 循 环, 而 do-while 语 句 则 是 直 到 型 循 环 语 句 do 循 环 体 while( 表 达 式 ) ; 32. 当 型 循 环 语 句 是 分 析 本 题 知 识 点 与 上 题 相 同 while() 循 环 体 for ( 表 达 式 1; 表 达 式 2; 表 达 式 3) 循 环 体 33. 调 试 题 下 列 程 序, 使 其 完 成 如 下 的 功 能, 即 : 查 找 100 至 999 之 间 所 有 符 合 以 下 条 件 的 数 : 是 另 一 数 的 平 方 ; 至 少 有 两 位 数 是 相 同 的 如 数 144, 它 是 12 的 平 方, 其 中 有 两 位 4 代 码 int n,m,a,b,c; for ( n = 10; n <= 31; n++ ) m = n*n; a = m / 10; b = m / 10 % 10; c = m / 100 % 10; if ( a==b && b==c && a==c ) printf( "%d ", n ); 33

34 分 析 题 意 是 至 少 有 两 位 数 是 相 同 的 因 此 表 达 式 a==b && b==c && a==c 与 题 意 不 符, 应 改 成 :a==b b==c a==c 正 确 的 代 码 #include "stdio.h" int n,m,a,b,c; for ( n = 10; n <= 31; n++ ) m = n*n; a = m%10; b = m / 10 % 10; c = m / 100 % 10; if ( a==b b==c a==c ) printf( "%d ", m ); 34. 调 试 题 下 列 程 序, 使 其 完 成 如 下 的 功 能, 即 : (1) 输 入 若 干 个 学 生 成 绩, 若 输 入 数 据 大 于 100 或 小 于 0( 除 -999 外 ), 则 不 作 记 录, 重 新 输 入 ; 当 输 入 999, 则 输 入 结 束 (2) 统 计 所 有 输 入 成 绩 的 最 大 值 最 小 值 成 绩 个 数 平 均 值, 并 输 出 之 代 码 int mark, n = 0, sum = 0; int max = 0, min = 100; for( ; ; ); scanf("%d", mark); if ( mark = -999 ) if ( mark > 100 ) break; printf("mark>100, Reinput!\n"); n++; if ( mark>max ) else sum %= n; min = mark; break; sum += mark; max = mark printf("%d,%d,%d,%d\n", max,min,n,sum); 分 析 代 码 中 出 现 for( ; ; ); 这 里 的 分 号 构 成 一 个 循 环 体, 构 成 循 环 体 的 是 空 语 句, 那 么 题 目 中 的 输 入 成 绩 计 算 最 高 分 最 低 分 和 平 均 分 的 功 能 都 无 法 实 现, 按 程 序 的 功 能 描 述 循 环 体 就 是 完 成 计 算 功 能 的 语 句, 因 此, 这 个 分 号 必 须 删 除, 希 望 牢 记 在 循 环 语 句 中 正 确 应 用 分 号 在 程 序 中 应 关 注 数 据 输 入 前 的 提 示, 并 正 确 调 用 scanf, 代 码 中 出 现 scanf("%d", 34

35 mark); 是 错 的, 输 入 函 数 要 求 参 数 为 变 量 的 地 址 不 是 变 量 名 代 码 中 出 现 if ( mark = -999 ) break; 是 错 的, 这 里 mark 是 通 过 scanf 输 入 数 据 的, 此 处 应 判 断 其 值 是 否 为 -999, 而 判 断 应 使 用 关 系 运 算 符 号 = =, 代 码 :if ( mark > 100 ) break; printf("mark>100, Reinput!\n"); 中 有 两 处 错, 其 一, 判 断 中 缺 少 mark<0 的 情 况 ; 其 二, 数 据 输 入 有 误 应 重 新 输 入 而 不 是 退 出 循 环 体, 在 处 理 最 高 分 最 低 分 时 也 存 在 错 误, 不 是 最 高 分 不 一 定 是 最 低 分, 因 此 是 否 最 低 分 需 要 判 断 后 才 能 确 定, 计 算 平 均 分 的 表 达 式 语 句 也 是 错 的, 平 均 分 应 是 总 分 除 人 数 而 不 是 对 人 数 求 余, 输 出 的 数 据 应 有 相 应 的 说 明, 而 代 码 中 的 输 出 只 有 数 值 正 确 的 代 码 #include "stdio.h" int mark, n = 0, sum = 0; int max = 0, min = 100; for( ; ; ) printf(" 输 入 %d 个 学 生 成 绩 \n",n+1); scanf("%d", &mark); if ( mark==-999 )break; if ( mark > 100 mark<0) printf("mark>100, mark<0,reinput!\n"); continue; n++; sum += mark; if ( mark>max ) sum /= n; else if(mark<min) max = mark; min = mark; printf(" 最 高 分 :%d, 最 低 分 :%d, 学 生 数 :%d, 平 均 分 :%d\n", max,min,n,sum); 35. 程 序 功 能 为 : 一 个 5 位 数, 判 断 它 是 不 是 回 文 数 例 如 :12321 是 回 文 数, 其 规 律 是 : 个 位 与 万 位 相 同, 十 位 与 千 位 相 同 填 写 正 确 的 语 句 或 表 达 式 使 程 序 能 正 确 运 行 代 码 #include "stdio.h" long x,j=1; for( ) if( ) printf("%6d",x);if( ) printf("\n");j++; 分 析 一 个 5 位 的 回 文 数, 首 先 是 一 个 5 位 数, 其 范 围 为 :10000~99999, 程 序 的 思 路 是 在 5 位 数 的 范 围 内 逐 一 判 断 其 是 否 满 足 条 件 个 位 与 万 位 相 同, 十 位 与 千 位 相 同, 因 此, for 的 3 个 表 达 式 分 别 为 :x=10000;x<=99999;x++;if 的 判 断 条 件 则 是 将 文 字 个 位 与 万 位 相 同, 十 位 与 千 位 相 同 写 成 逻 辑 表 达 式, 即 :x%10==x/10000&&x/10%10==x/1000%10; 由 于 5 位 回 文 数 很 多, 为 了 输 出 清 晰, 每 行 输 出 5 个 数 值, 代 码 中 第 2 个 if 语 句 的 判 断 条 件 则 是 控 制 每 行 输 出 5 个 数 值, 因 此, 此 处 应 填 写 逻 辑 表 达 式!(j%5) 或 关 系 表 达 公 式 j%5==0 35

36 完 整 的 代 码 #include "stdio.h" long x,j=1; for(x=10000;x<=99999;x++) if(x%10==x/10000&&x/10%10==x/1000%10) printf("%6d",x);if(!(j%5) ) printf("\n");j++; 36. 程 序 功 能 为 : 求 1000 以 内 所 有 解, 其 条 件 为 : 有 物 不 知 几 何, 三 三 数 余 一, 五 五 数 余 二, 七 七 数 余 三, 问 : 物 有 几 何? 填 写 正 确 的 语 句 或 表 达 式 使 程 序 能 正 确 运 行 代 码 #include stdio.h int m,count=0; for( ) if( ) printf( %5d,m);count++; if( ) printf( \n ); 分 析 题 目 求 解 范 围 为 :52~1000, 程 序 的 思 路 是 在 范 围 内 逐 一 判 断 其 是 否 满 足 题 目 中 描 述 的 条 件, 因 此,for 的 3 个 表 达 式 分 别 为 :m=1;m<=1000;m++;if 的 判 断 条 件 则 是 将 文 字 写 成 逻 辑 表 达 式, 即 :m%3==1&&m%5==2&&m%7==3; 每 行 输 出 5 个 数 值, 代 码 中 第 2 个 if 语 句 的 判 断 条 件 则 是 控 制 每 行 输 出 5 个 数 值, 因 此, 此 处 应 填 写 逻 辑 表 达 式!( count %5) 或 关 系 表 达 公 式 count %5==0 完 整 的 代 码 #include stdio.h int m,count=0; for(m=1;m<=1000;m++) if(m%3==1&&m%5==2&&m%7==3), printf( %5d,m);count++; if(count%5==0) printf( \n ); 37. 编 程, 求 1-1/2+1/3-1/4+ +1/99-1/100 之 值 分 析 根 据 循 环 变 量 的 数 值 控 制 累 加 项 的 正 负 完 整 的 代 码 # include <stdio.h> 36

37 int i; float s; s=0; for (i=1;i<=100;i++) if (i%2==0) /* 偶 数 时 累 加 (-1)/ i */ s=s-1.0/i; else s=s+1.0/i; /* 奇 数 时 累 加 1/i */ printf( s=%f,s); 练 一 练 一 单 选 题 (16 分 ) 1 程 序 设 计 的 基 本 结 构 中 一 般 不 提 倡 使 用 A. 跳 转 B. 选 择 C. 顺 序 D. 循 环 2 下 列 叙 述 正 确 的 是 A.C 程 序 由 函 数 和 过 程 组 成 B.C 程 序 由 函 数 构 成 C.C 程 序 由 主 函 数 组 成 D. 以 上 均 可 3 sizeof (double) 是 A. 一 种 函 数 调 用 B. 一 个 不 合 法 表 达 式 C. 一 种 关 系 表 达 式 D. 一 个 算 术 的 表 达 式 4 为 了 避 免 嵌 套 的 if-else 的 二 义 性,C 语 言 的 语 法 规 定 :else 与 配 对 A. 缩 排 位 置 相 同 的 if B. 与 之 前 最 近 的 未 配 对 的 if C. 其 之 后 最 近 的 if D. 同 一 行 上 的 if 5 下 列 错 误 的 语 句 是 A.if (a>b) printf(" %d ", a) ; B.if ( ) ; a=m ; C.if (1) a=m ; else a=n ; D.if ( a>0) ; else a=n ; 6 下 面 的 for 语 句 执 行 时, 将 形 成 无 限 循 环 A. for(s=j=0; j<100; j+=1) s+=j; B. for(s=j=0; j<100; j+1) s+=j; C. for(s=j=0; j<100; ++j) s+=j-1; D. for(s=j=0; j<100; j++) s+= j; 7 运 行 下 列 程 序, 其 输 出 结 果 为 #include <stdio.h> main( ) 37

38 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) ; A.a=2,b=1 B.a=1,b=1 C.a=1,b=0 D.a=2,b=2 8 C 语 言 程 序 中 可 以 对 程 序 进 行 注 释, 注 释 部 分 必 须 用 符 号 括 起 来 A. 和 B. [ 和 ] C. /* 和 */ D. */ 和 /* 二 填 空 题 (4 分 ) 1 若 有 int x=10, y=2 ; 则 表 达 式 (int)5.0+x/y 的 值 为 2 若 定 义 unsigned a = 11006, b = ; 则 表 达 式 a^b^b 的 值 为 3 C 语 言 中 的 标 识 符 只 能 由 三 种 字 符 组 成, 它 们 是 字 母 数 字 w log ( x 8 x y 4 试 写 出 数 学 式 y) 的 C 语 言 表 达 式 三 程 序 调 试 题 ( 下 列 各 程 序 中 存 在 一 些 问 题, 通 过 调 试 发 现 问 题, 并 加 以 修 正, 使 其 实 现 预 期 目 标 (20 分 )) 1 下 列 程 序 的 功 能 是 : 读 入 3 个 数, 并 输 出 这 3 个 数 程 序 3.1 int a; float b; fchar c; scanf("%c%d%c%f"; c,b,a,b); 2 下 列 程 序 功 能 : (1) 输 入 若 干 个 学 生 成 绩, 若 输 入 数 据 大 于 100 或 小 于 0( 除 -999 外 ), 则 不 作 记 录, 重 新 输 入 ; 当 输 入 999, 则 输 入 结 束. 统 计 所 有 输 入 成 绩 的 最 大 值, 最 小 值, 成 绩 个 数, 平 均 值, 并 输 出 之. 程 序

39 int mark, n = 0, sum = 0; int max = 0, min = 100; for( ; ; ); scanf("%d", mark); if ( mark = -999 ) if ( mark > 100 ) break; printf("mark>100, Reinput!\n"); n++; break; if ( mark>max ) else sum %= n; sum += mark; min = mark; max = mark printf("%d,%d,%d,%d\n", max,min,n,sum); 四 程 序 填 空 题 ( 请 填 写 适 当 的 符 号, 使 程 序 实 现 其 功 能 (30 分 )) 1 下 列 程 序 的 功 能 是 : 输 出 字 符 串 China 程 序 4.1 #include <stdio.h> char ch1, ch2; int i; ch1= C ; ch2= h ; i= ; putchar( ); ; putchar(i); putchar( n ); putchar( \141 ); putchar( \n ); 2 一 个 5 位 数, 判 断 它 是 不 是 回 文 数 即 是 回 文 数, 个 位 与 万 位 相 同, 十 位 与 千 位 相 同 程 序 4.2 #include "stdio.h" long x,j=1; if( ) for( ) printf("%6d",x);if( ) printf("\n");j++; 五 编 程 (30 分 ) 39

40 1. 编 写 程 序, 根 据 上 网 时 间 x 计 算 上 网 费 用 y, 计 算 的 方 法 如 下 : 当 x< 10 小 时, 上 网 费 用 : y=20 元 套 餐 费 当 10<=x<50 小 时, 上 网 费 用 : 套 餐 费 加 超 过 10 小 时 部 分 每 小 时 3 元 当 x>=50 小 时, 上 网 费 用 : 套 餐 费 加 超 过 10 小 时 部 分 每 小 时 2.5 元 同 时 为 了 鼓 励 多 上 网, 每 月 收 费 最 多 不 超 过 170 元 2. 将 一 张 面 值 为 50 元 的 人 民 币 等 值 换 成 5 元 1 元 和 0.5 元 的 零 钞, 要 求 每 种 零 钞 不 少 于 1 张, 问 有 哪 几 种 组 合? 40

41 第 2 章 模 块 设 计 一 个 较 大 的 程 序 通 常 分 为 若 干 个 子 程 序 模 块, 每 个 子 程 序 模 块 实 现 一 个 特 定 的 功 能 函 数 就 是 实 现 特 定 功 能 的 程 序 模 块, 利 用 函 数, 不 仅 可 以 实 现 程 序 的 模 块 化, 使 得 程 序 设 计 简 单 直 观, 提 高 程 序 的 可 读 性 和 可 维 护 性, 而 且 还 可 以 将 一 些 常 用 的 算 法 编 写 成 通 用 函 数, 以 供 随 时 调 用 因 此 无 论 C 程 序 的 设 计 规 模 有 多 大 多 复 杂, 都 是 划 分 为 若 干 个 相 对 独 立 功 能 较 单 一 的 函 数, 通 过 对 这 些 函 数 的 调 用, 从 而 实 现 程 序 功 能 的 C 语 言 也 被 称 为 是 函 数 式 语 言 图 2-1 函 数 知 识 网 络 图 2.1 函 数 的 定 义 任 何 函 数 ( 包 括 主 函 数 ) 都 是 由 函 数 说 明 和 函 数 体 两 部 分 组 成 (1) 一 个 源 程 序 文 件 由 一 个 或 多 个 函 数 构 成, 每 个 函 数 完 成 一 个 相 对 独 立 的 任 务 一 个 源 程 41

42 序 文 件 是 一 个 编 译 单 位, 即 Turbo C 系 统 是 以 源 程 序 为 单 位 进 行 编 译, 而 不 是 以 函 数 为 单 位 进 行 编 译 (2) 一 个 C 程 序 是 由 一 个 或 多 个 源 程 序 文 件 组 成 C 程 序 的 执 行 从 main 函 数 开 始, 调 用 其 他 函 数 后 流 程 返 回 到 main 函 数, 在 main 函 数 中 结 束 整 个 程 序 的 运 行 (3) 所 有 函 数 在 定 义 时 都 是 相 互 独 立 的, 他 们 之 间 的 关 系 是 平 行 的 一 个 函 数 并 不 从 属 于 另 一 个 函 数, 也 就 是 说, 在 一 个 函 数 的 函 数 体 内, 不 能 再 定 义 另 一 个 函 数, 即 函 数 不 能 嵌 套 定 义 函 数 间 可 以 相 互 调 用, 但 不 能 调 用 main 函 数 (4) 从 函 数 定 义 的 角 度, 函 数 分 为 两 种 : 标 准 函 数 和 用 户 自 己 定 义 的 函 数 而 如 果 从 函 数 参 数 的 角 度, 函 数 则 可 分 为 无 参 函 数 和 有 参 函 数 两 类 无 参 函 数 的 定 义 形 式 函 数 定 义 函 数 说 明 函 数 调 用 均 不 带 参 数, 主 调 函 数 和 被 调 函 数 之 间 不 进 行 参 数 传 递, 此 类 函 数 通 常 用 来 完 成 一 组 指 定 的 功 能, 可 以 返 回 或 不 返 回 函 数 值 其 定 义 形 式 : 类 型 标 识 符 函 数 名 ( ) 说 明 部 分 ; 可 执 行 语 句 部 分 ; 其 中 类 型 标 识 符 连 同 函 数 名 和 整 个 圆 括 号 对 一 起 被 称 为 函 数 首 部 类 型 标 识 符 指 定 函 数 值 的 类 型, 即 函 数 返 回 值 的 类 型 函 数 名 是 由 用 户 定 义 的 标 识 符, 函 数 名 后 面 必 须 有 一 对 空 括 号 (), 其 中 没 有 参 数, 但 圆 括 号 对 不 可 少 花 括 号 对 中 的 内 容 称 为 函 数 体, 由 说 明 部 分 和 可 执 行 语 句 部 分 组 成 有 参 函 数 的 定 义 形 式 有 参 函 数 的 函 数 定 义 和 函 数 说 明 部 分 都 有 参 数 其 定 义 形 式 : 类 型 标 识 符 函 数 名 ( 数 据 类 型 参 数 [, 数 据 类 型 参 数 2 ] ) 说 明 部 分 ; 可 执 行 语 句 部 分 ; 有 参 函 数 比 无 参 函 数 多 了 一 个 参 数 表 列, 称 为 形 式 参 数 表 列 有 参 数 函 数 被 调 用 时, 调 用 函 数 将 一 一 对 应 地 赋 予 这 些 形 式 参 数 实 际 的 值, 也 就 是 说 : 用 实 际 参 数 向 形 式 参 数 传 值 为 了 与 调 用 函 数 提 供 的 实 际 参 数 区 别 开, 将 函 数 定 义 中 的 参 数 表 称 为 形 式 参 数 表, 简 称 形 参 表 在 形 参 表 中 给 出 的 参 数 称 为 形 式 参 数, 它 们 可 以 是 各 种 类 型 的 变 量, 各 参 数 之 间 用 逗 号 间 隔 在 进 行 函 数 调 用 时, 主 调 函 数 将 赋 予 这 些 形 式 参 数 实 际 的 值 形 参 既 然 是 变 量, 当 然 必 须 给 以 类 型 说 明 在 C 程 序 中, 一 个 函 数 的 定 义 可 以 放 在 任 意 位 置, 既 可 放 在 主 函 数 main 之 前, 也 可 放 在 main 之 后 42

43 如 同 变 量 一 样,C 语 言 的 基 本 规 则 是 先 定 义, 后 使 用, 或 者 是 先 声 明 再 使 用, 最 后 定 义 如 果 被 调 用 函 数 的 使 用 在 先, 定 义 在 后, 则 在 主 调 函 数 调 用 该 函 数 前 应 对 它 进 行 声 明, 目 的 是 使 编 译 系 统 把 这 个 信 息 当 作 函 数 处 理 其 一 般 形 式 为 : 类 型 说 明 符 被 调 函 数 名 ( 类 型 形 参, 类 型 形 参 ); 或 为 : 类 型 说 明 符 被 调 函 数 名 ( 类 型, 类 型 ); 括 号 内 给 出 了 形 参 的 类 型 和 形 参 名, 或 只 给 出 形 参 类 型 这 便 于 编 译 系 统 进 行 语 法 检 查 2.2 函 数 的 调 用 函 数 调 用, 就 是 指 主 调 函 数 中 调 用 函 数 的 形 式 和 方 法 函 数 调 用 的 一 般 形 式 一 个 C 程 序 可 由 一 个 主 函 数 和 若 干 个 函 数 组 成 程 序 执 行 时, 从 主 函 数 开 始, 通 过 主 函 数 调 用 其 他 函 数, 其 他 函 数 也 可 以 相 互 调 用 同 一 个 函 数 可 以 被 一 个 或 多 个 函 数 调 用 所 有 函 数 都 可 以 调 用 库 函 数 函 数 调 用 的 一 般 形 式 为 : 函 数 名 ( 实 参 表 列 ); 实 际 参 数 表 中 的 参 数 可 以 是 常 数, 变 量 或 其 它 构 造 类 型 数 据 及 表 达 式 各 实 参 之 间 用 逗 号 分 隔 如 果 是 调 用 无 参 函 数, 则 实 参 表 列 可 以 没 有, 但 函 数 名 后 的 一 对 园 括 号 ( ) 不 能 省 略, 如 printstar( ); 实 参 的 个 数 类 型 和 顺 序, 应 该 与 被 调 用 函 数 所 要 求 的 参 数 个 数 类 型 和 顺 序 一 致, 才 能 正 确 地 进 行 数 据 传 递 调 用 一 个 已 经 定 义 的 函 数, 就 意 味 着 在 程 序 的 调 用 处 完 成 了 该 函 数 的 功 能 C 语 言 提 供 了 以 下 三 种 函 数 调 用 方 式 : (1) 函 数 语 句 函 数 调 用 的 一 般 形 式 加 上 分 号 即 构 成 函 数 语 句, 这 时 的 函 数 调 用 可 作 为 一 条 独 立 的 语 句 这 种 调 用 方 式, 函 数 一 般 无 值 返 回 或 者 函 数 有 值 返 回, 但 不 是 通 过 return 语 句 返 回, 而 是 直 接 利 用 指 针 参 数 带 出 函 数 体 (2) 函 数 表 达 式 函 数 的 调 用 出 现 在 表 达 式 中, 这 种 表 达 式 称 为 函 数 表 达 式 这 时 要 求 函 数 带 回 一 个 确 定 的 值 以 参 加 表 达 式 的 运 算 (3) 函 数 实 参 函 数 作 为 另 一 个 函 数 调 用 的 实 际 参 数 出 现 这 种 情 况 是 把 该 函 数 的 返 回 值 作 为 实 参 进 行 传 送, 因 此 要 求 该 函 数 必 须 是 有 返 回 值 的 函 数 的 返 回 值 函 数 的 值 是 指 函 数 被 调 用 之 后, 执 行 函 数 体 中 的 程 序 段 所 取 并 返 回 给 主 调 函 数 的 值 例 如 调 用 正 弦 函 数 取 得 正 弦 值, 调 用 max 函 数 取 得 的 最 大 数 等 43

44 对 函 数 的 值 ( 或 称 函 数 返 回 值 ) 有 以 下 一 些 说 明 : 函 数 的 值 是 通 过 return 语 句 返 回 主 调 函 数 return 语 句 的 一 般 形 式 有 三 种 : return; return 表 达 式 ; return ( 表 达 式 ); 第 1 种 返 回 语 句 是 代 表 函 数 停 止 执 行, 返 回 主 调 函 数, 但 并 不 带 回 返 回 值 ; 第 2 种 和 第 3 种 语 句 的 功 能 是 一 样 的, 首 先 计 算 表 达 式 的 值, 然 后 把 表 达 式 的 值 返 回 给 主 调 函 数 在 函 数 中 允 许 有 多 个 return 语 句, 但 当 函 数 执 行 完 任 何 一 个 return 语 句 后, 被 调 用 函 数 就 不 再 执 行 其 它 的 后 继 指 令, 而 是 将 控 制 返 回 到 主 调 函 数, 因 此 只 能 返 回 一 个 函 数 值 函 数 值 的 类 型 和 函 数 定 义 中 函 数 的 类 型 应 保 持 一 致 如 果 两 者 不 一 致, 则 以 函 数 类 型 为 准, 自 动 进 行 类 型 转 换 如 函 数 值 为 整 型, 在 函 数 定 义 时 可 以 省 去 类 型 说 明 不 返 回 函 数 值 的 函 数, 可 以 明 确 定 义 为 空 类 型, 类 型 说 明 符 为 void 一 旦 函 数 被 定 义 为 空 类 型 后, 就 不 能 在 主 调 函 数 中 使 用 被 调 函 数 的 函 数 值 了 例 如, 在 定 义 s 为 空 类 型 后, 在 主 函 数 中 写 下 述 语 句 sum=s(n); 就 是 错 误 的 为 了 使 程 序 有 良 好 的 可 读 性 并 减 少 出 错, 凡 不 要 求 返 回 值 的 函 数 都 应 定 义 为 空 类 型 对 被 调 用 函 数 的 声 明 一 个 函 数 能 被 另 一 个 函 数 调 用 需 要 以 下 几 个 条 件 : (1) 该 函 数 必 须 已 经 存 在, 无 论 是 库 函 数 还 是 用 户 自 定 义 函 数 (2) 调 用 库 函 数 时, 不 需 要 对 函 数 作 声 明, 只 需 在 源 程 序 的 开 头 用 #include 命 令 将 相 关 的 头 文 件 包 含 进 来 如 :printf() scanf () getchar() putchar() 等 函 数 原 型 声 明 在 <stdio.h> 头 文 件 中,sin() sqrt() 等 函 数 原 型 声 明 在 <math.h> 头 文 件 中 (3) 调 用 用 户 自 定 义 函 数 时, 一 般 应 在 主 调 函 数 的 开 始 部 分 对 被 调 函 数 作 声 明 其 一 般 形 式 为 : 类 型 说 明 符 函 数 名 ( 形 参 及 形 参 类 型 说 明 ); C 语 言 中 规 定 在 以 下 几 种 情 况 时 可 以 省 去 主 调 函 数 中 对 被 调 函 数 的 函 数 声 明 (1) 如 果 被 调 函 数 的 返 回 值 是 整 型 或 字 符 型 时, 可 以 不 对 被 调 函 数 做 说 明, 而 直 接 调 用 这 时 系 统 将 自 动 对 被 调 函 数 返 回 值 按 整 型 处 理 (2) 当 被 调 函 数 的 函 数 定 义 出 现 在 主 调 函 数 之 前 时, 在 主 调 函 数 中 也 可 以 不 对 被 调 函 数 再 作 说 明 而 直 接 调 用 例 如 例 3.1 中, 函 数 max 的 定 义 放 在 main 函 数 之 前, 因 此 可 在 main 函 数 中 省 去 对 max 函 数 的 函 数 说 明 int max(int a,int b) (3) 如 果 在 所 有 函 数 定 义 之 前, 在 函 数 外 预 先 说 明 了 各 个 函 数 的 类 型, 则 在 以 后 的 各 主 调 函 数 中, 可 不 再 对 被 调 函 数 作 说 明 (4) 对 库 函 数 的 调 用 不 需 要 再 作 说 明, 但 必 须 把 该 函 数 的 头 文 件 用 include 命 令 包 含 在 源 文 件 前 面 (5) 如 果 使 用 用 户 自 己 定 义 的 函 数, 而 且 该 函 数 与 调 用 它 的 函 数 ( 即 主 调 函 数 ) 在 同 一 个 文 件 中, 一 般 还 应 该 在 主 调 函 数 中 对 被 调 用 函 数 的 返 回 值 的 类 型 作 说 明 这 种 类 型 声 明 的 一 般 形 式 为 : 类 型 标 识 符 被 调 用 函 数 的 函 数 名 () 44

45 2.2.4 函 数 的 嵌 套 调 用 C 语 言 中 不 允 许 作 嵌 套 的 函 数 定 义, 因 此 各 函 数 之 间 是 平 行 的, 不 存 在 上 一 级 函 数 和 下 一 级 函 数 的 问 题 但 是 C 语 言 允 许 在 一 个 函 数 的 定 义 中 出 现 对 另 一 个 函 数 的 调 用 这 样 就 出 现 了 函 数 的 嵌 套 调 用 函 数 的 嵌 套 调 用 是 指, 在 执 行 被 调 用 函 数 时, 被 调 用 函 数 又 调 用 了 其 它 函 数 这 与 其 它 语 言 的 子 程 序 嵌 套 调 用 的 情 形 是 类 似 的 函 数 的 递 归 调 用 递 归 的 定 义 C 语 言 允 许 函 数 的 递 归 调 用, 函 数 的 递 归 调 用 是 指, 一 个 函 数 在 它 的 函 数 体 内, 直 接 或 间 接 地 调 用 它 自 身 在 递 归 调 用 中, 主 调 函 数 又 是 被 调 函 数, 执 行 递 归 函 数 将 反 复 调 用 其 自 身 每 调 用 一 次 就 进 入 新 的 一 层 递 归 调 用 分 为 直 接 递 归 和 间 接 递 归, 直 接 递 归 是 在 函 数 中 调 用 了 本 身, 间 接 递 归 是 函 数 调 用 了 别 的 函 数, 别 的 函 数 又 调 用 了 自 己 虽 然 递 归 是 直 接 或 间 接 地 调 用 本 身, 但 同 调 用 其 它 函 数 一 样, 每 次 调 用 都 需 要 为 被 调 函 数 开 辟 新 的 内 存 空 间, 也 就 是 说 同 一 个 函 数 的 多 次 调 用 并 不 共 用 同 一 内 存 空 间 因 此 调 用 本 身 和 调 用 其 它 函 数 的 调 用 过 程 是 一 样 的 递 归 条 件 采 用 递 归 方 法 来 解 决 问 题, 必 须 符 合 以 下 三 个 条 件 : (1) 可 以 把 要 解 决 的 问 题 转 化 为 一 个 新 问 题, 而 这 个 新 的 问 题 的 解 决 方 法 仍 与 原 来 的 解 决 方 法 相 同, 只 是 所 处 理 的 对 象 有 规 律 地 递 增 或 递 减 ( 解 决 问 题 的 方 法 相 同, 调 用 函 数 的 参 数 每 次 不 同 ( 有 规 律 的 递 增 或 递 减 ), 如 果 没 有 规 律 也 就 不 能 适 用 递 归 调 用 ) (2) 可 以 应 用 这 个 转 化 过 程 使 问 题 得 到 解 决 ( 使 用 其 他 的 办 法 比 较 麻 烦 或 很 难 解 决, 而 使 用 递 归 的 方 法 可 以 很 好 地 解 决 问 题 ) (3) 必 定 要 有 一 个 明 确 的 结 束 递 归 的 条 件 ( 一 定 要 能 够 在 适 当 的 地 方 结 束 递 归 调 用 不 然 可 能 导 致 系 统 崩 溃 ) 递 归 说 明 (1) 当 函 数 自 己 调 用 自 己 时, 系 统 将 自 动 把 函 数 中 当 前 的 变 量 和 形 参 暂 时 保 留 起 来, 在 新 一 轮 的 调 用 过 程 中, 系 统 为 新 调 用 的 函 数 所 用 到 的 变 量 和 形 参 开 辟 另 外 的 存 储 单 元 ( 内 存 空 间 ) 每 次 调 用 函 数 所 使 用 的 变 量 在 不 同 的 内 存 空 间 (2) 递 归 调 用 的 层 次 越 多, 同 名 变 量 的 占 用 的 存 储 单 元 也 就 越 多 每 次 函 数 的 调 用, 系 统 都 会 为 该 函 数 的 变 量 开 辟 新 的 内 存 空 间 (3) 当 本 次 调 用 的 函 数 运 行 结 束 时, 系 统 将 释 放 本 次 调 用 时 所 占 用 的 内 存 空 间 程 序 的 流 程 返 回 到 上 一 层 的 调 用 点, 同 时 取 得 当 初 进 入 该 层 时, 函 数 中 的 变 量 和 形 参 所 占 用 的 内 存 空 间 的 数 据 (4) 所 有 递 归 问 题 都 可 以 用 非 递 归 的 方 法 来 解 决, 但 对 于 一 些 比 较 复 杂 的 递 归 问 题 用 非 递 归 的 方 法 往 往 使 程 序 变 得 十 分 复 杂 难 以 读 懂, 而 函 数 的 递 归 调 用 在 解 决 这 类 问 题 时 能 使 程 序 简 洁 明 了 有 较 好 的 可 读 性 ; 但 由 于 递 归 调 用 过 程 中, 系 统 要 为 每 一 层 调 用 中 的 变 量 开 辟 内 存 空 间 要 记 住 每 一 层 调 用 后 的 返 回 点 要 增 加 许 多 额 外 的 开 销, 因 此 函 数 的 递 归 调 用 通 常 会 降 低 程 序 的 运 行 效 率 45

46 2.3 函 数 的 参 数 所 有 在 函 数 内 部 定 义 的 变 量 叫 局 部 变 量, 作 用 域 限 于 本 函 数 体 内 ; 在 函 数 外 部 定 义 的 变 量 叫 全 局 变 量, 其 作 用 域 从 定 义 的 位 置 到 整 个 程 序 结 束 函 数 的 参 数 有 形 式 参 数 ( 形 参 ) 和 实 在 参 数 ( 实 参 ) 之 分, 形 参 和 实 参 的 功 能 是 完 成 数 据 传 送 发 生 函 数 调 用 时, 主 调 函 数 把 实 参 的 值 传 送 给 被 调 函 数 的 形 参 从 而 实 现 主 调 函 数 向 被 调 函 数 的 数 据 传 送 它 们 具 有 以 下 特 点 : 形 式 参 数 : 在 定 义 函 数 时 函 数 名 后 面 括 弧 中 的 变 量 名 表 列, 是 局 部 变 量, 其 作 用 域 限 于 本 函 数 体 内 局 部 变 量 只 有 在 函 数 被 调 用 时 才 分 配 内 存 单 元, 在 调 用 结 束 时, 即 刻 释 放 所 分 配 的 内 存 单 元 形 参 也 是 局 部 变 量, 因 此, 形 参 只 有 在 函 数 内 部 有 效 函 数 调 用 结 束 返 回 主 调 函 数 后 则 不 能 再 使 用 形 参 变 量 实 际 参 数 : 被 调 用 函 数 名 后 面 括 弧 中 的 表 达 式 表 列, 如 果 其 中 某 个 表 达 式 是 主 调 函 数 的 局 部 变 量, 由 于 函 数 之 间 呈 并 列 关 系, 因 而 各 自 的 局 部 变 量 也 相 互 并 列, 当 控 制 进 入 被 调 用 函 数 后, 它 们 随 之 失 去 了 作 用 域, 以 至 这 些 作 为 实 参 的 变 量 不 能 在 被 调 用 函 数 体 内 使 用 实 参 可 以 是 常 量 变 量 表 达 式 函 数 等, 无 论 实 参 是 何 种 类 型 的 量, 在 进 行 函 数 调 用 前, 它 们 都 必 须 具 有 确 定 的 值, 以 便 把 这 些 值 传 送 给 形 参 因 此 应 预 先 用 赋 值, 输 入 等 办 法 使 实 参 获 得 确 定 值 实 参 向 形 参 传 值 时, 在 数 量 上, 类 型 上, 顺 序 上 应 严 格 一 致, 否 则 会 发 生 类 型 不 匹 配 的 错 误 函 数 调 用 时 数 据 传 送 是 单 向 的, 即 只 能 是 实 参 单 向 把 值 传 送 给 形 参, 而 形 参 不 会 把 值 反 向 传 送 给 实 参 或 者 说 : 形 参 的 任 何 变 化 改 变 不 了 实 参 的 值 如 果 实 参 是 数 值 变 量, 传 给 形 参 后, 不 论 该 值 发 生 什 么 变 化, 当 然 影 响 不 到 实 参 ; 如 果 实 参 是 地 址 值, 虽 然 该 地 址 值 不 会 改 变, 但 该 地 址 所 指 的 存 储 单 元 内 容 却 可 以 被 改 变 在 函 数 的 调 用 过 程 中, 大 部 分 都 存 在 着 数 据 上 的 联 系, 主 要 表 现 在 两 个 方 面 : 一 是 外 部 数 据 如 何 传 递 到 函 数 内 部 ; 另 一 是 函 数 内 部 加 工 过 的 数 据 如 何 传 递 给 外 部 程 序 因 此 C 程 序 中, 函 数 间 的 参 数 传 递 有 两 个 方 面 : (1) 函 数 调 用 时 传 递 给 函 数 的 值 ; (2) 函 数 调 用 结 束 时 返 回 给 主 调 函 数 的 值 值 传 递 是 将 实 参 的 值 传 递 给 形 参, 函 数 调 用 结 束 后, 形 参 当 前 的 值 并 不 回 传 给 实 参 因 此 值 传 递 方 式 是 单 向 数 据 传 递 在 C 语 言 中, 当 形 参 是 变 量, 实 参 是 表 达 式 ( 可 以 是 常 量 变 量 等 ), 参 数 间 的 数 据 传 递 是 值 传 递 传 递 过 程 是 先 计 算 实 参 的 值, 进 入 函 数 调 用 时, 系 统 为 形 参 分 配 存 储 空 间, 然 后 将 实 参 的 具 体 数 值 传 递 到 相 应 的 形 参 中 这 样 在 函 数 内 部, 通 过 对 形 参 的 操 作 实 现 对 外 部 数 据 的 引 用 当 函 数 调 用 结 束 时, 系 统 收 回 形 参 所 占 的 存 储 空 间 值 传 递 的 特 点 : 形 参 和 实 参 各 自 占 用 不 同 的 存 储 空 间, 在 函 数 内 部 对 形 参 的 任 何 操 作, 其 结 果 只 能 影 响 形 参 的 值, 而 不 会 影 响 到 实 参 的 值 这 种 方 式 只 能 实 现 外 部 数 据 向 函 数 内 部 的 传 递, 不 能 实 现 函 数 内 部 数 据 向 外 传 递 地 址 传 递 是 将 数 据 的 存 储 地 址 作 为 实 参 传 递 给 形 参 按 这 种 方 式 传 递 时, 形 参 的 类 型 必 须 是 指 针 变 量 或 数 组 名, 而 实 参 的 类 型 也 只 能 是 变 量 的 地 址 数 组 名 ( 数 组 的 首 地 址 ) 或 指 针 变 量 地 址 传 递 的 特 点 : 实 参 和 形 参 指 向 同 一 个 内 存 单 元 地 址, 即 数 据 在 主 调 函 数 和 被 调 函 数 中 占 用 相 同 的 存 储 单 元, 因 此 对 形 参 的 操 作 会 影 响 实 参 的 值 46

47 2.4 变 量 的 作 用 域 和 存 储 类 别 变 量 的 作 用 域 所 谓 变 量 的 作 用 域 就 是 指 变 量 能 被 有 效 引 用 的 范 围 据 此,C 语 言 将 变 量 分 为 局 部 变 量 和 全 局 变 量 局 部 变 量 在 一 个 函 数 内 部 定 义 的 变 量 是 内 部 变 量, 它 只 在 本 函 数 范 围 内 有 效, 也 就 是 说 只 有 在 本 函 数 内 才 能 使 用 它 们, 在 此 函 数 以 外 是 不 能 使 用 这 些 变 量 的 离 开 该 函 数 后 再 使 用 这 种 变 量 是 非 法 的, 这 样 的 变 量 称 为 局 部 变 量 局 部 变 量 也 称 为 内 部 变 量 全 局 变 量 在 函 数 内 定 义 的 变 量 是 局 部 变 量, 而 在 函 数 之 外 定 义 的 变 量 称 为 外 部 变 量, 外 部 变 量 是 全 局 变 量 它 不 属 于 哪 一 个 函 数, 它 属 于 一 个 源 程 序 文 件 全 局 变 量 可 以 为 本 文 件 中 其 它 函 数 所 共 用 它 的 有 效 范 围 为 : 从 定 义 变 量 的 位 置 开 始 到 本 源 文 件 的 结 束 在 函 数 中 使 用 全 局 变 量, 一 般 应 作 全 局 变 量 说 明 只 有 在 函 数 内 经 过 说 明 的 全 局 变 量 才 能 使 用 全 局 变 量 的 说 明 符 为 extern 但 在 一 个 函 数 之 前 定 义 的 全 局 变 量, 在 该 函 数 内 使 用 可 不 再 加 以 说 明 对 于 全 局 变 量 还 有 以 下 几 点 说 明 : (1) 对 于 局 部 变 量 的 定 义 和 说 明, 可 以 不 加 区 分 而 对 于 外 部 变 量 则 不 然, 外 部 变 量 的 定 义 和 外 部 变 量 的 说 明 并 不 是 一 回 事 外 部 变 量 的 定 义 只 能 有 一 次, 它 的 位 置 在 所 有 函 数 之 外, 且 只 能 定 义 一 次 其 一 般 形 式 为 : [extern] 类 型 说 明 符 变 量 名, 变 量 名 ; 其 中 方 括 号 内 的 extern 可 以 省 去 不 写 而 同 一 文 件 中 的 外 部 变 量 的 说 明 可 以 有 多 次, 它 的 位 置 在 函 数 之 内 ( 哪 个 函 数 要 用 就 在 哪 个 函 数 中 说 明 ) 外 部 变 量 说 明 的 一 般 形 式 为 : extern 类 型 说 明 符 变 量 名, 变 量 名, ; 外 部 变 量 在 定 义 时 就 已 分 配 了 内 存 单 元, 外 部 变 量 定 义 可 作 初 始 赋 值, 外 部 变 量 说 明 不 能 再 赋 初 始 值, 只 是 表 明 在 函 数 内 要 使 用 某 外 部 变 量 系 统 根 据 外 部 变 量 的 定 义 ( 而 不 是 根 据 外 部 变 量 的 说 明 ) 分 配 存 储 单 元 对 外 部 变 量 的 初 始 化 只 能 在 定 义 时 进 行, 而 不 能 在 说 明 中 进 行 所 谓 说 明, 其 作 用 是 : 声 明 该 变 量 是 一 个 已 在 外 部 定 义 过 的 变 量, 仅 仅 是 为 了 引 用 该 变 量 而 作 的 声 明 原 则 上, 所 有 函 数 都 应 当 对 所 有 的 外 部 变 量 作 说 明 ( 用 extern), 只 是 为 了 简 化 起 见, 允 许 在 外 部 变 量 的 定 义 点 之 后 的 函 数 可 以 省 略 这 个 说 明 (2) 在 同 一 源 文 件 中, 允 许 全 局 变 量 和 局 部 变 量 同 名 在 局 部 变 量 的 作 用 域 内, 全 局 变 量 不 起 作 用 (3) 全 局 变 量 的 作 用 是 增 加 了 函 数 间 数 据 联 系 的 渠 道 由 于 函 数 的 调 用 只 能 带 回 一 个 返 回 值, 因 此 有 时 可 以 利 用 全 局 变 量 增 加 与 函 数 联 系 的 渠 道, 从 函 数 得 到 一 个 以 上 的 返 回 值 (4) 如 果 外 部 变 量 在 文 件 开 头 定 义, 则 在 整 个 文 件 范 围 内 都 可 以 使 用 该 外 部 变 量, 如 果 不 在 文 件 开 头 定 义, 按 上 面 规 定 作 用 范 围 只 限 于 定 义 点 到 文 件 结 束 如 果 在 定 义 点 之 前 的 函 数 想 引 用 该 外 部 变 量, 则 应 该 在 该 函 数 中 用 关 键 字 extern 作 外 部 变 量 说 明 表 示 该 变 量 在 函 数 的 外 部 定 义, 在 函 数 内 部 可 以 使 用 它 们 47

48 全 局 变 量 的 使 用 为 函 数 间 的 数 据 交 流 提 供 了 方 便, 但 多 个 函 数 访 问 同 一 个 全 局 变 量 就 会 增 加 函 数 间 的 联 系 在 模 块 化 程 序 设 计 思 想 中 要 求 模 块 间 的 关 系 尽 量 少, 使 用 全 局 变 量 与 模 块 化 程 序 设 计 思 想 冲 突 ; 另 外, 全 局 变 量 在 整 个 程 序 运 行 过 程 中 都 占 用 内 存, 所 以 应 尽 量 少 使 用 全 局 变 量 变 量 的 存 储 类 别 变 量 的 存 储 方 式 是 指 变 量 使 用 内 存 空 间 的 方 式, 通 常 可 分 为 静 态 存 储 和 动 态 存 储 两 种 静 态 存 储 变 量 通 常 是 在 变 量 定 义 时 就 分 配 存 储 单 元 并 一 直 保 持 不 变, 直 至 整 个 程 序 结 束 全 局 变 量 属 于 此 类 存 储 方 式 动 态 存 储 变 量 是 在 程 序 执 行 过 程 中, 使 用 它 时 才 分 配 存 储 单 元, 使 用 完 毕 立 即 释 放 典 型 的 例 子 是 函 数 的 形 式 参 数, 在 函 数 定 义 时 并 不 给 形 参 分 配 存 储 单 元, 只 是 在 函 数 被 调 用 时, 才 予 以 分 配, 调 用 函 数 完 毕 立 即 释 放 如 果 一 个 函 数 被 多 次 调 用, 则 反 复 地 分 配 释 放 形 参 变 量 的 存 储 单 元 由 以 上 分 析 可 知, 静 态 存 储 变 量 是 一 直 存 在 的, 而 动 态 存 储 变 量 则 时 而 存 在 时 而 消 失 这 种 由 于 变 量 存 储 方 式 不 同 而 产 生 的 特 性 称 变 量 的 生 存 期 生 存 期 表 示 了 变 量 存 在 的 时 间 生 存 期 和 作 用 域 是 从 时 间 和 空 间 这 两 个 不 同 的 角 度 来 描 述 变 量 的 特 性, 这 两 者 既 有 联 系, 又 有 区 别 一 个 变 量 究 竟 属 于 哪 一 种 存 储 方 式, 并 不 能 仅 从 其 作 用 域 来 判 断, 还 应 有 明 确 的 存 储 类 型 说 明 在 C 语 言 中, 对 变 量 的 存 储 类 型 说 明 有 以 下 四 种 : auto 自 动 变 量 register 寄 存 器 变 量 extern 外 部 变 量 static 静 态 变 量 自 动 变 量 和 寄 存 器 变 量 属 于 动 态 存 储 方 式, 外 部 变 量 和 静 态 变 量 属 于 静 态 存 储 方 式 因 此, 对 一 个 变 量 的 说 明 不 仅 应 说 明 其 数 据 类 型, 还 应 说 明 其 存 储 类 型 变 量 说 明 的 完 整 形 式 为 : 存 储 类 型 说 明 符 数 据 类 型 说 明 符 变 量 名, 变 量 名 ; 1. 自 动 变 量 在 变 量 定 义 的 类 型 前 面 加 上 auto, 就 将 变 量 说 明 为 自 动 类 型 其 一 般 形 式 为 : [auto] 数 据 类 型 变 量 表 ; C 语 言 规 定, 函 数 内 凡 未 加 存 储 类 型 说 明 的 变 量 均 视 为 自 动 变 量, 也 就 是 说 自 动 变 量 可 省 去 说 明 符 auto 自 动 变 量 具 有 以 下 特 点 : (1) 自 动 变 量 只 在 该 函 数 内 有 效, 函 数 被 调 用 时 分 配 存 储 空 间, 调 用 结 束 就 释 放 而 在 复 合 语 句 中 定 义 的 自 动 变 量 只 在 该 复 合 语 句 中 有 效 (2) 自 动 变 量 属 于 动 态 存 储 方 式, 只 有 在 使 用 它, 即 定 义 该 变 量 的 函 数 被 调 用 时 才 给 它 分 配 存 储 单 元, 开 始 它 的 生 存 期 函 数 调 用 结 束, 释 放 存 储 单 元, 结 束 生 存 期 因 此 函 数 调 用 结 束 之 后, 自 动 变 量 的 值 不 能 保 留 在 复 合 语 句 中 定 义 的 自 动 变 量, 在 退 出 复 合 语 句 后 也 不 能 再 使 用, 否 则 将 引 起 错 误 (3) 定 义 而 不 初 始 化, 则 其 值 是 不 确 定 的 如 果 初 始 化, 则 赋 初 值 操 作 是 在 调 用 时 进 行 的, 且 每 次 调 用 都 要 重 新 赋 一 次 初 值 (4) 由 于 自 动 变 量 的 作 用 域 和 生 存 期 都 局 限 于 定 义 它 的 个 体 内 ( 函 数 或 复 合 语 句 内 ), 因 48

49 此 不 同 的 个 体 中 允 许 使 用 同 名 的 变 量 而 不 会 混 淆 即 使 在 函 数 内 定 义 的 自 动 变 量 也 可 与 该 函 数 内 部 的 复 合 语 句 中 定 义 的 自 动 变 量 同 名 2. 寄 存 器 变 量 上 述 各 类 变 量 都 存 放 在 存 储 器 内, 因 此 当 对 一 个 变 量 频 繁 读 写 时, 必 须 要 反 复 访 问 内 存 储 器, 从 而 花 费 大 量 的 存 取 时 间 为 此,C 语 言 提 供 了 另 一 种 变 量, 即 寄 存 器 变 量 这 种 变 量 存 放 在 CPU 的 寄 存 器 中, 使 用 时, 不 需 要 访 问 内 存, 而 直 接 从 寄 存 器 中 读 写, 这 样 可 提 高 效 率 寄 存 器 变 量 的 说 明 符 是 register 对 于 循 环 次 数 较 多 的 循 环 控 制 变 量 及 循 环 体 内 反 复 使 用 的 变 量 均 可 定 义 为 寄 存 器 变 量 定 义 格 式 如 下 : register 数 据 类 型 变 量 表 ; 对 寄 存 器 变 量 还 要 说 明 以 下 几 点 : (1) 只 有 局 部 自 动 变 量 和 形 式 参 数 才 可 以 定 义 为 寄 存 器 变 量, 即 全 局 变 量 不 行 因 为 寄 存 器 变 量 属 于 动 态 存 储 方 式 所 以 凡 需 要 采 用 静 态 存 储 方 式 的 量 不 能 定 义 为 寄 存 器 变 量 (2) 对 寄 存 器 变 量 的 实 际 处 理, 随 系 统 而 异 (3) 即 使 能 真 正 使 用 寄 存 器 变 量 的 机 器, 由 于 CPU 中 寄 存 器 的 个 数 是 有 限 的, 因 此 使 用 寄 存 器 变 量 的 个 数 也 是 有 限 的 3. 静 态 变 量 外 部 变 量 属 于 静 态 存 储 方 式, 静 态 变 量 的 类 型 说 明 符 是 static 定 义 格 式 : static 数 据 类 型 内 部 变 量 表 ; 静 态 变 量 虽 然 属 于 静 态 存 储 方 式, 但 是 属 于 静 态 存 储 方 式 的 量 不 一 定 就 是 静 态 变 量, 例 如 外 部 变 量 虽 属 于 静 态 存 储 方 式, 但 不 一 定 是 静 态 变 量, 必 须 由 static 加 以 定 义 后 才 能 成 为 静 态 外 部 变 量, 或 称 静 态 全 局 变 量 自 动 变 量 属 于 动 态 存 储 方 式 但 是 也 可 以 用 static 定 义 它 为 静 态 自 动 变 量, 或 称 静 态 局 部 变 量, 从 而 成 为 静 态 存 储 方 式 由 此 看 来, 一 个 变 量 可 由 static 进 行 再 说 明, 并 改 变 其 原 有 的 存 储 方 式 (1) 静 态 局 部 变 量 在 局 部 变 量 的 说 明 前 再 加 上 说 明 符 static 就 构 成 静 态 局 部 变 量 例 如 : static int a,b; static float array[5]=1,2,3,4,5; 静 态 局 部 变 量 属 于 静 态 存 储 方 式, 它 具 有 以 下 特 点 : 1 静 态 局 部 变 量 在 函 数 内 定 义, 但 不 象 自 动 变 量 那 样, 当 调 用 时 就 存 在, 退 出 函 数 时 就 消 失 静 态 局 部 变 量 始 终 存 在 着, 也 就 是 说 它 的 生 存 期 为 整 个 源 程 序 2 静 态 局 部 变 量 的 生 存 期 虽 然 为 整 个 源 程 序, 但 是 其 作 用 域 仍 与 自 动 变 量 相 同, 即 只 能 在 定 义 该 变 量 的 函 数 内 使 用 该 变 量 退 出 该 函 数 后, 尽 管 该 变 量 还 继 续 存 在, 但 不 能 使 用 它 3 允 许 对 构 造 类 静 态 局 部 量 赋 初 值 若 未 赋 以 初 值, 则 由 系 统 自 动 赋 以 0 值 (2) 静 态 全 局 变 量 全 局 变 量 ( 外 部 变 量 ) 的 说 明 之 前 再 冠 以 static 就 构 成 了 静 态 的 全 局 变 量 全 局 变 量 本 身 就 是 静 态 存 储 方 式, 静 态 全 局 变 量 当 然 也 是 静 态 存 储 方 式 这 两 者 在 存 储 方 式 上 并 无 不 同, 区 别 在 于 非 静 态 全 局 变 量 的 作 用 域 是 整 个 源 程 序, 当 一 个 源 程 序 由 多 个 源 文 件 组 成 时, 非 静 态 的 全 局 变 量 在 各 个 源 文 件 中 都 是 有 效 的 而 静 态 全 局 变 量 只 在 定 义 该 变 量 的 源 文 件 内 有 效, 在 同 一 源 程 序 的 其 它 源 文 件 中 不 能 使 用 它 由 于 静 态 全 局 变 量 的 作 用 域 局 限 于 一 个 源 文 件 内, 只 能 为 该 源 文 件 内 的 函 数 共 用, 因 此 可 以 避 免 在 其 它 源 文 件 中 引 起 错 误 从 以 上 分 析 可 以 看 出, 把 局 部 变 量 改 变 为 静 态 变 量 后 是 改 变 了 它 的 存 储 方 式 即 改 变 了 它 的 生 49

50 存 期, 把 全 局 变 量 改 变 为 静 态 变 量 后 是 改 变 了 它 的 作 用 域, 限 制 了 它 的 使 用 范 围 因 此 static 这 个 说 明 符 在 不 同 的 地 方 所 起 的 作 用 是 不 同 的 4. 外 部 变 量 外 部 类 型 变 量 ( 简 称 外 部 变 量 ) 是 定 义 在 所 有 函 数 之 外 的 全 局 变 量, 在 所 有 函 数 体 内 部 都 是 有 效 的, 因 此 函 数 间 可 以 通 过 外 部 变 量 直 接 共 享 数 据 在 变 量 定 义 的 类 型 前 面 加 上 extern, 就 将 变 量 说 明 为 外 部 类 型 其 一 般 形 式 为 : extern 类 型 说 明 符 变 量 名 1, 变 量 名 2,, 变 量 名 n; 如 果 外 部 变 量 的 定 义 与 使 用 在 同 一 个 文 件 中, 则 该 文 件 的 函 数 在 使 用 外 部 变 量 时 不 需 进 行 其 他 说 明, 直 接 可 以 使 用 ; 如 果 外 部 变 量 的 定 义 与 使 用 在 两 个 不 同 的 文 件 中, 则 在 使 用 外 部 变 量 之 前 用 extern 存 储 类 型 加 以 说 明 内 部 函 数 和 外 部 函 数 内 部 函 数 如 果 在 一 个 源 文 件 中 定 义 的 函 数 只 能 被 本 文 件 中 的 函 数 调 用, 而 不 能 被 同 一 源 程 序 其 它 文 件 中 的 函 数 调 用, 这 种 函 数 称 为 内 部 函 数 定 义 内 部 函 数 的 一 般 形 式 是 : static 类 型 说 明 符 函 数 名 ( 形 参 表 ) 内 部 函 数 也 称 为 静 态 函 数, 但 此 处 静 态 static 的 含 义 已 不 是 指 存 储 方 式, 而 是 指 对 函 数 的 调 用 范 围 只 局 限 于 本 文 件 因 此 在 不 同 的 源 文 件 中 定 义 同 名 的 静 态 函 数 不 会 引 起 混 淆 外 部 函 数 在 一 个 源 文 件 的 函 数 中 调 用 其 它 源 文 件 中 定 义 的 外 部 函 数 时, 应 用 extern 说 明 被 调 函 数 为 外 部 函 数 外 部 函 数 在 整 个 源 程 序 中 都 有 效, 其 定 义 的 一 般 形 式 为 : extern 类 型 说 明 符 函 数 名 ( 形 参 表 ) 如 果 在 函 数 定 义 中 没 有 说 明 extern 或 static, 则 隐 含 为 extern 调 用 外 部 函 数 时, 需 要 对 其 进 行 说 明 : [extern] 函 数 类 型 函 数 名 ( 参 数 类 型 表 )[, 函 数 名 2( 参 数 类 型 表 2) ]; 2.5 典 型 案 例 分 析 1. 自 定 义 函 数 之 间 及 它 们 和 主 函 数 之 间 是 什 么 关 系? 分 析 所 有 的 函 数 都 是 平 行 的, 即 在 定 义 函 数 时 是 相 互 独 立 的, 一 个 函 数 并 不 从 属 于 另 一 个 函 数, 函 数 之 间 不 能 嵌 套 定 义, 可 以 相 互 调 用, 但 不 能 调 用 主 函 数 C 程 序 的 执 行 从 主 函 数 开 始, 也 结 束 于 主 函 数 2. 函 数 的 定 义 和 声 明 有 何 不 同? 分 析 函 数 的 定 义 是 给 出 函 数 的 功 能, 其 中 包 括 指 定 函 数 名 函 数 值 类 型 形 参 及 其 类 型 函 数 体 等, 是 对 函 数 的 一 个 完 整 叙 述 函 数 声 明 的 作 用 是 把 函 数 的 名 字 函 数 类 型 以 及 形 参 的 类 型 个 数 和 顺 序 通 知 编 译 系 统, 以 便 在 调 用 该 函 数 时 系 统 进 行 语 法 检 查 3. 函 数 间 参 数 传 递 方 式 如 何 确 定? 50

51 分 析 形 参 与 实 参 的 结 合 有 传 值 传 址 和 引 用 等 方 式 形 参 是 变 量 名, 这 是 传 值 方 式, 它 是 单 向 的, 即 只 能 从 外 界 向 函 数 传 入 初 值, 但 不 能 将 结 果 传 出 形 参 是 指 针 或 数 组 名, 这 是 传 址 方 式, 它 是 双 向 的, 既 可 传 入 又 可 传 出 形 参 是 引 用, 其 作 用 同 传 址 方 式, 也 是 双 向 的, 但 它 比 传 址 方 式 更 方 便 直 接 4. 函 数 swap 是 交 换 两 变 量 的 值, 用 下 面 两 种 形 式 使 a,b 交 换 后 的 值 返 回 为 何 不 行? (1)int swap(int a,int b) int temp; temp=a;a=b;b=temp; return a,b; (2)int swap(int a,int b) int temp; temp=a;a=b;b=temp; return a; return b; 分 析 形 式 1 中 返 回 的 a,b 是 一 逗 号 表 达 式, 该 表 达 式 的 值 是 最 后 一 表 达 式 的 值 即 b 的 值, 所 以 它 只 能 把 b 值 返 回 ; 而 形 式 2 中 当 执 行 return a; 语 句 后 即 返 回 到 调 用 处 变 量 b 的 值 无 法 返 回 5. 函 数 定 义 函 数 说 明 与 函 数 调 用 的 区 别? 分 析 这 三 者 形 式 相 似, 但 不 相 同 函 数 调 用 提 供 一 组 实 参, 不 写 出 类 型 名 ; 函 数 说 明 和 函 数 头 不 知 道 函 数 调 用 时 提 供 的 值, 所 以 它 们 列 出 形 参 类 型 另 外, 函 数 定 义 必 须 给 出 形 参 名, 以 使 函 数 体 代 码 可 使 用 它 们 最 后 说 明 的 结 尾 有 一 分 号, 而 函 数 头 结 尾 没 有 6. 为 什 么 值 传 递 不 能 回 传 结 果? 分 析 函 数 在 值 传 递 调 用 时, 是 隐 含 地 把 实 参 的 值 分 别 赋 值 给 了 形 参, 之 后 在 被 调 用 函 数 体 内 再 也 没 有 对 实 参 进 行 任 何 的 操 作 了 操 作 的 只 是 形 参 变 量, 并 不 是 实 参, 当 然 实 参 的 值 没 有 发 生 改 变, 所 以 值 传 递 不 能 回 传 结 果 而 形 参 和 实 参 都 是 局 部 变 量, 它 们 的 作 用 范 围 都 是 在 本 函 数 内 部, 函 数 调 用 结 束 时 它 们 的 内 存 也 即 释 放, 所 以 形 参 值 的 变 化 对 实 参 没 有 影 响 例 如 : void exchg1(int x, int y) int t; t=x; x=y; y=t; void 51

52 int a=4,b=6; exchg1(a,b) ; printf( a=%d,b=%d\n,a,b) 程 序 运 行 后 变 量 a,b 的 值 仍 分 别 为 4 和 6, 原 因 在 于 函 数 在 调 用 时 是 隐 含 地 把 实 参 a,b 的 值 分 别 赋 值 给 了 x,y, 之 后 在 exchg1 函 数 体 内 再 也 没 有 对 a,b 进 行 任 何 的 操 作 了 交 换 的 只 是 x,y 变 量 并 不 是 a,b 当 然 a,b 的 值 没 有 发 生 改 变 7. 下 面 关 于 函 数 参 数 的 说 法 正 确 的 是 A. 函 数 必 须 要 有 参 数, 否 则 就 不 是 函 数 了 B. 实 参 变 量 对 形 参 变 量 的 数 据 传 递 是 值 传 递 C. 实 参 与 形 参 的 类 型 必 须 一 致 D. 定 义 函 数 时, 形 参 的 类 型 可 以 不 指 定 分 析 答 案 A 不 正 确, 函 数 可 以 是 无 参 函 数, 但 如 果 有 参 数, 必 须 指 定 具 体 的 数 据 类 型, 所 以 D 不 正 确, 实 参 和 形 参 的 数 据 类 型 不 一 定 要 一 致, 也 可 以 是 赋 值 兼 容 的 数 据 类 型, 所 以 C 不 正 确 因 此 本 题 的 正 确 答 案 为 B 8. 下 面 关 于 函 数 调 用 的 说 法 不 正 确 的 是 A. 函 数 可 以 嵌 套 调 用 B. 函 数 可 以 调 用 自 身, 形 成 递 归 调 用 C. 在 主 调 函 数 中 对 被 调 用 的 函 数 作 声 明 是 必 须 的 D. 如 果 调 用 无 参 函 数, 则 实 参 可 以 没 有, 但 是 括 号 不 能 省 略 分 析 在 主 调 函 数 中 声 明 被 调 用 函 数 不 是 必 须 的, 例 如 : 当 被 调 用 函 数 定 义 在 主 调 函 数 之 前, 就 不 需 要 声 明 因 此 本 题 的 正 确 答 案 为 C 9. 下 面 程 序 的 运 行 结 果 是 void swap(int x,int y) int t; t=x;x=y;y=t; printf("%d,%d ",x,y); #include <stdio.h> int a=1,b=2; swap(a,b); printf("%d,%d\n",a,b); A. 1,2 1,2 B. 2,1 1,2 C. 2,1 2,1 D. 1,2 2,1 分 析 此 题 考 核 了 函 数 调 用 的 过 程 中, 实 参 变 量 对 形 参 变 量 的 数 据 传 递 是 单 向 传 递 的, 故 而 在 swap 函 数 中 形 参 x 和 y 的 值 发 生 了 变 化, 但 是 实 际 参 数 a 和 b 的 值 并 未 变 化 因 此 本 题 的 正 确 答 案 为 B 10. 执 行 下 列 程 序, 运 行 结 果 为 int p=1,q=5; 52

53 int f1(int a) p=p+q; return(a+p); int f2(int a) p=a*2; return(p); #include <stdio.h> int c; c=f1(f2(3)); printf("f1(f2(3))=%d,p=%d,q=%d",c,p,q); A. f1(f2(3))=12,p=6,q=5 B. f1(f2(3))=12,p=1,q=5 C. f1(f2(3))=17,p=11,q=5 D. f1(f2(3))=17,p=6,q=5 分 析 此 题 考 核 了 全 局 变 量 和 局 部 变 量 的 概 念, 难 点 在 于 求 p 的 值,p 和 q 是 全 局 变 量, 在 调 用 函 数 f2 和 f1 后,p 的 值 都 会 发 生 变 化, 依 次 为 6 11 因 此 本 题 的 正 确 答 案 为 C 11. 下 面 关 于 局 部 变 量 和 全 局 变 量 的 说 法 正 确 的 是 A. 在 main 函 数 中 定 义 的 变 量 是 全 局 变 量 B. 在 任 何 函 数 中 定 义 的 变 量 都 是 局 部 变 量 C. 所 有 的 全 局 变 量 都 是 在 程 序 运 行 期 间 根 据 需 要 动 态 分 配 存 储 空 间 的 D. 所 有 的 局 部 变 量 都 是 在 程 序 运 行 期 间 根 据 需 要 动 态 分 配 存 储 空 间 的 分 析 答 案 A 不 正 确, 在 main 中 定 义 的 变 量 也 是 局 部 变 量,C 不 对, 全 局 变 量 是 静 态 存 储 方 式,D 不 正 确, 局 部 变 量 有 些 是 动 态 存 储 方 式, 有 些 是 静 态 存 储 方 式, 如 用 static 声 明 的 局 部 变 量 就 是 静 态 存 储 方 式 因 此 本 题 的 正 确 答 案 为 B 12. 程 序 运 行 结 果 是 #include <stdio.h> f(int a) static int c=5; c++; return(a+c); int i; for (i=0;i<=2;i++) printf("%d ",f(i)); 53

54 A B C D 分 析 此 题 考 核 了 静 态 变 量 的 概 念, 函 数 f 中 静 态 变 量 c, 在 每 次 函 数 调 用 结 束 后, 它 并 不 释 放, 依 然 保 留 着 上 次 调 用 函 数 结 束 时 的 值 因 此 本 题 的 正 确 答 案 为 D 13. 该 程 序 的 执 行 结 果 是 #include <stdio.h> func(int a,int b) static int m=0,i=2; i+=m+1; m=i+a+b; return (m); int k=4,m=1,p; p=func(k,m); printf("%d",p); p=func(k,m); printf(",%d\n",p); A.8,15 B.8,16 C.8,17 D.8,8 分 析 fun 函 数 中 的 m 和 i 都 是 静 态 变 量, 在 整 个 程 序 运 行 期 间, 静 态 局 部 变 量 占 据 着 永 久 性 的 存 储 单 元, 即 使 退 出 函 数 以 后, 下 次 再 进 入 改 函 数 时, 静 态 局 部 变 量 仍 使 用 原 来 的 存 储 单 元 第 1 次 调 用 时 m 置 初 值 0,i 置 初 值 2, 退 出 该 函 数 时 m 和 i 不 会 释 放 存 储 空 间, 以 后 再 调 用 func 时, 不 再 给 m 和 i 置 初 值, 直 接 使 用 它 们 以 前 的 结 果 所 以 本 题 答 案 为 :C 14. 什 么 是 形 参? 什 么 是 实 参? 分 析 在 定 义 函 数 时 函 数 名 后 面 括 弧 中 的 变 量 名 称 为 形 参, 在 主 调 函 数 中 调 用 一 个 函 数 时, 函 数 名 后 面 括 弧 中 的 参 数 称 为 实 参 实 参 与 形 参 的 类 型 应 相 同 或 赋 值 相 容, 实 参 变 量 对 形 参 变 量 的 数 据 传 递 是 值 传 递, 即 单 向 传 递, 只 由 实 参 传 给 形 参, 而 不 能 由 形 参 传 回 给 实 参 15. 函 数 调 用 的 方 式 有 哪 些? 分 析 有 三 种 : 一 是 函 数 语 句, 此 时 函 数 没 有 带 回 值 ; 二 是 函 数 表 达 式, 此 时 函 数 带 回 一 个 确 定 的 值 ; 三 是 函 数 参 数, 即 函 数 调 用 作 为 一 个 函 数 的 实 参, 此 时 函 数 也 要 带 回 一 个 确 定 的 值 16. 如 果 在 同 一 文 件 中, 使 用 自 己 定 义 的 函 数, 是 否 一 定 要 在 主 调 函 数 中 声 明 被 调 用 的 函 数? 分 析 不 是 必 须 的 要 求, 有 两 种 情 况 可 以 不 声 明 : 第 一, 如 果 被 调 用 的 函 数 的 定 义 出 现 在 主 调 函 数 之 前 ; 第 二, 如 果 被 调 用 的 函 数 类 型 是 整 型, 但 这 种 情 况, 建 议 最 好 还 是 为 了 程 序 清 晰 和 安 全, 加 以 声 明 为 好 17. 在 主 函 数 中 定 义 的 变 量 是 全 局 变 量 吗? 分 析 不 是 的, 主 函 数 中 定 义 的 变 量 也 只 有 在 主 函 数 中 有 效, 是 局 部 变 量 18. 下 面 关 于 函 数 的 说 法 正 确 的 是 A. 任 何 一 个 C 程 序 都 由 函 数 构 成 B. 如 果 函 数 值 的 类 型 和 return 语 句 中 表 达 式 的 值 不 一 致, 则 以 return 语 句 中 表 达 式 的 类 型 为 准 54

55 C. 凡 不 加 函 数 值 类 型 说 明 的 函 数, 一 律 自 动 按 void 类 型 处 理 D. 实 参 不 可 以 是 表 达 式 分 析 答 案 B 不 正 确, 应 该 以 函 数 值 的 类 型 为 准, 答 案 C 中, 一 律 按 整 型 处 理, 答 案 D 中, 实 参 可 以 是 表 达 式 因 此 本 题 的 正 确 答 案 为 A 19. 函 数 max(1.3,2.8) 的 值 是 max(float x,float y) float z; z=x>y?x:y; return(z); A. 3 B. 2.8 C. 2 D. 1 分 析 max 函 数 定 义 时, 没 有 添 加 类 型 说 明 符, 默 认 函 数 值 的 类 型 为 整 型, 虽 然 与 return 语 句 中 表 达 式 的 值 ( 实 型 ) 不 一 致, 以 函 数 类 型 为 准, 即 为 整 型, 需 要 将 实 型 数 据 转 换 为 整 型 ( 即 2.8 转 换 为 2) 因 此 本 题 的 正 确 答 案 为 C 20. 下 面 程 序 的 运 行 结 果 为 f(int x,int y) int m; if (x>y) m=x-y; if (x<=y) m=y-x; return(m); int i=5; int c; c=f(i++,i--); printf("%d",c); A. -1 B. 0 C. 2 D. 1 分 析 f(i++,i--) 等 价 于 f(5,6) 因 此 本 题 的 正 确 答 案 为 D 21.C 语 言 规 定, 函 数 返 回 值 的 类 型 是 由 A) return 语 句 中 的 表 达 式 类 型 所 决 定 B) 调 用 函 数 时 的 主 调 函 数 类 型 所 决 定 C) 调 用 函 数 时 系 统 临 时 决 定 D) 在 定 义 该 函 数 时 所 指 定 的 函 数 类 型 所 决 定 分 析 函 数 返 回 值 通 常 是 指 通 过 函 数 调 用 而 使 主 调 函 数 能 得 到 的 一 个 确 定 的 值, 是 通 过 函 数 中 的 return 语 句 获 得 的, 值 的 类 型 应 当 在 定 义 函 数 时 指 定, 在 C 语 言 中, 凡 不 加 类 型 说 明 的 函 数, 自 动 按 整 型 处 理 如 果 函 数 值 的 类 型 和 return 语 句 中 表 达 式 的 值 不 一 致, 则 以 函 数 类 型 为 准 对 数 值 型 数 据, 可 以 自 动 进 行 类 型 转 换 即 函 数 类 型 决 定 返 回 值 的 类 型 所 以, 正 确 答 案 为 :D 22. 如 下 程 序 : #include <stdio,h> 55

56 max(int x,int y); int a,b,c; scanf(" %d,%d ",&a,&b); c=max(a,b); print(" a=%d,b=%d,max=%d\n ",a,b,c); int max(x,y) int x,y; int z; if(x>y)z=x; else z=y; return(z); 运 行 时, 键 入 3,6 并 回 车, 可 得 到 结 果 A. a=3,b=6,max=6 B.a=6,b=6,max=6 C. a=3,b=3,max=6 D. a=3,b=6,max=3 分 析 该 题 中, 主 函 数 通 过 调 用 max() 函 数 得 到 两 数 中 较 大 的 一 个 数 的 值 进 行 输 出, 如 本 题 中 的 6 就 是 函 数 的 返 回 值 函 数 的 返 回 值 是 通 过 函 数 中 的 return 语 句 获 得 的 return 语 句 将 被 调 用 函 数 中 的 一 个 确 定 值 带 回 到 主 调 函 数 中 去 所 以, 正 确 答 案 为 :A 23. 以 下 程 序 运 算 的 结 果 是 int f2(int b) b=b*b; return b; void f1(int b) b=++b,b+f2(b); printf(" %d\n ",b); int a=1; f1(a); 分 析 本 题 总 共 有 3 个 函 数 ;main 函 数,f1 函 数,f2 函 数 其 中 f1 函 数 的 返 回 值 为 void 类 型, 它 是 作 为 一 个 单 独 的 语 句 存 在 于 调 用 函 数 中 的, 而 f2 函 数 功 能 为 求 值, 它 作 为 一 个 值 的 形 式 出 现 在 调 用 函 数 f1 的 表 达 式 中 本 题 易 错 的 地 方 首 先 在 于 函 数 比 较 多, 调 用 关 系 相 对 复 杂, 读 者 要 立 清 思 路 ; 第 二 个 易 错 的 地 方 是 逗 号 表 达 式 和 自 加 符 号 的 连 用 当 这 些 知 识 点 放 在 一 起 时, 许 多 初 学 者 很 容 易 搞 混 淆, 应 该 细 心 沉 着 地 一 步 一 步 分 析, 这 个 表 达 式 首 先 执 行 了 "++b", 然 后 把 自 加 后 的 b 作 为 实 参 调 用 函 数 所 以, 正 确 答 案 为 :2 24. 以 下 程 序 通 过 函 数 SunFun 求 f(0)+f(1)+f(2)+ +f(10) 这 里 f(x)=x*x+1, 由 F 函 数 实 现 请 56

57 填 空 #include <stdio.h> printf(" The sum=%d\n ",Sunfun(10)); SunFun(int n) int x,s=0; for(x=0;x<=n;x++) s+=f( ); return s; F(int x) return ( ); 分 析 本 题 考 查 了 函 数 调 用 的 一 些 基 本 语 法 结 构 经 过 结 构 分 析, 可 以 得 出 F 函 数 的 功 能 就 是 时 间 题 目 中 的 f(x)=x*x+1 功 能, 主 函 数 就 是 实 现 累 加 功 能, 所 以 [2] 很 容 易 得 到 x*x+1 在 主 函 数 中 是 把 x 作 为 循 环 变 量 以 实 现 数 值 递 加 的, 那 么 就 是 把 x 作 为 F 的 实 参, 所 以 [1] 就 是 x 这 是 一 道 典 型 的 很 熟 调 用 的 题 目, 它 的 运 行 流 程 是, 首 先 main 函 数 要 调 用 SunFun 函 数 以 完 成 输 出 行 为, 而 SunFun 函 数 完 成 的 是 求 和 功 能,F 函 数 完 成 f(x) 函 数 的 功 能, 由 此 功 能 化 的 三 模 块 之 间 的 相 互 调 用, 完 成 了 题 目 的 要 求 所 以, 正 确 答 案 为 :[1]x [2]x*x 阅 读 下 列 程 序, 则 运 行 结 果 为 #include "stdio.h" fun() static int x=5; x++ return x; int i,x; for(i=0;i<3;i++) x=fun(); printf("%d\n",x); A. 5 B. 6 C. 7 D. 8 分 析 对 于 为 赋 予 初 值 的 静 态 局 部 变 量,C 编 译 程 序 自 动 给 它 赋 初 值 0 本 题 由 于 连 续 3 次 调 用 函 数 fun(),3 次 对 静 态 变 量 x 进 行 操 作, 因 此 x 的 值 应 依 次 为 6,7,8 所 以, 正 确 答 案 为 :D 26. 下 程 序 的 运 行 结 果 为 #include <stdio.h> f(int a) 57

58 auto int b=0; static c=3; b=b+1; c+c+1; return(a+b+c); int a=2,i; for(i=0;i<3;i++) printf("%d",f(a)); A B C D. 无 输 出 结 果 分 析 本 程 序 中, 考 查 了 auto 类 型 的 使 用, 难 点 在 变 量 的 作 用 范 围 f() 函 数 内 的 b 为 局 部 变 量,c 为 静 态 变 量, 第 一 次 调 用 开 始 时 b=0,c=3, 在 函 数 执 行 c=c+1 后,c 变 成 4 第 二 次 调 用 时,c 保 持 上 次 调 用 结 束 时 的 值 4, 在 函 数 执 行 c=c+1 后,c 变 成 5,b 重 新 赋 值 为 0, 依 此 类 推 所 以, 正 确 答 案 为 :B 27. 以 下 程 序 的 运 行 结 果 #include <stdio.h> func(int a,int b) static int m=0,i=2; i+=m+1; m=i+a+b; return m; int k=4,m=1,p; p=func(k,m); printf("%d",p); p=func(k,m); printf("%d",p); A. 8,8 B. 17,17 C. 8,17 D. 17,8 分 析 第 一 次 调 用 func(4,1), 在 func() 中, 执 行 "i+=m+1;" 之 后 i=3, 执 行 "m=i+a+b;" 之 后 m=8, 所 以 返 回 8; 第 二 次 调 用 func(4,1), 在 func() 中, 执 行 "i+=m+1;" 之 后 ( 此 前 i=3,m=8)i=12 执 行 "m=i+a+b;" 之 后 m=17 因 此, 输 出 为 8,17 内 部 静 态 变 量 在 第 一 次 进 入 包 含 它 的 函 数 赋 值 后, 以 后 再 进 入 该 函 数 时 赋 初 值 语 句 将 不 起 作 用 所 以, 正 确 答 案 为 :C 28. 下 程 序 的 运 行 结 果 为 int vs(int l,int w) 58

59 extern int h; int v; v=l*w*h; return v; extern int w,h; int l=5; printf("v=%d",vs(l,w)); 分 析 本 例 程 序 中, 外 部 变 量 在 最 后 定 义, 因 此 在 前 面 函 数 中 对 要 用 的 外 部 变 量 必 须 进 行 说 明 外 部 变 量 l,w 和 vs 函 数 的 形 参 l,w 同 名 外 部 变 量 都 作 了 初 始 赋 值,mian 函 数 中 也 对 l 作 了 初 始 化 赋 值 执 行 程 序 时, 在 printf 语 句 中 调 用 vs 函 数, 实 参 l 的 值 应 为 main 中 定 义 的 l 值, 等 于 5, 外 部 变 量 l 在 main 内 不 起 作 用 ; 实 参 w 的 值 为 外 部 变 量 w 的 值 为 4, 进 入 vs 后 这 两 个 值 传 送 给 形 参 l,wvs 函 数 中 使 用 的 h 为 外 部 变 量, 其 值 为 5, 因 此 v 的 计 算 结 果 为 100, 返 回 主 函 数 后 输 出 29. 从 键 盘 输 入 一 个 数 字 n, 计 算 n 的 值, 并 输 出 结 果 void int n; printf("input number\n"); scanf("%d",&n); s(n); printf("n=%d\n",n); int s(int n) int i; for(i=n-1;i>=1;i--) n=n+i; printf("n=%d\n",n); 分 析 本 程 序 中 定 义 了 一 个 函 数 s, 该 函 数 的 功 能 是 求 ni=1i 的 值 在 主 函 数 中 输 入 n 值, 并 作 为 实 参, 在 调 用 时 传 送 给 s 函 数 的 形 参 量 n( 注 意, 本 例 的 形 参 变 量 和 实 参 变 量 的 标 识 符 都 为 n, 但 这 是 两 个 不 同 的 量, 各 自 的 作 用 域 不 同 ) 在 主 函 数 中 用 printf 语 句 输 出 一 次 n 值, 这 个 n 值 是 实 参 n 的 值 在 函 数 s 中 也 用 printf 语 句 输 出 了 一 次 n 值, 这 个 n 值 是 形 参 最 后 取 得 的 n 值 0 从 运 行 情 况 看, 输 入 n 值 为 100 即 实 参 n 的 值 为 100 把 此 值 传 给 函 数 s 时, 形 参 n 的 初 值 也 为 100, 在 执 行 函 数 过 程 中, 形 参 n 的 值 变 为 5050 返 回 主 函 数 之 后, 输 出 实 参 n 的 值 仍 为 100 可 见 实 参 的 值 不 随 形 参 的 变 化 而 变 化 30. 判 别 一 个 整 数 数 组 中 各 元 素 的 值, 若 大 于 0 则 输 出 该 值, 若 小 于 等 于 0 则 输 出 0 值 编 程 如 下 : void nzp(int v) 59

60 if(v>0) printf("%d",v); else printf("%d",0); int a[5],i; printf("input 5 numbers\n"); for(i=0;i<5;i++) scanf("%d",&a[i]); nzp(a[i]); int a[5],i; printf("input 5 numbers\n"); for(i=0;i<5;i++) scanf("%d",&a[i]); nzp(a[i]); 分 析 本 程 序 中 首 先 定 义 一 个 无 返 回 值 函 数 nzp, 并 说 明 其 形 参 v 为 整 型 变 量 在 函 数 体 中 根 据 v 值 输 出 相 应 的 结 果 在 main 函 数 中 用 一 个 for 语 句 输 入 数 组 各 元 素, 每 输 入 一 个 就 以 该 元 素 作 实 参 调 用 一 次 nzp 函 数, 即 把 a[i] 的 值 传 送 给 形 参 v, 供 nzp 函 数 使 用 练 一 练 一 单 选 题 1. 关 于 建 立 函 数 的 目 的 以 下 说 法 正 确 的 是 B A. 提 高 程 序 的 执 行 效 率 B. 提 高 程 序 的 可 读 性 C. 减 少 程 序 的 篇 幅 D. 减 少 程 序 文 件 所 占 内 存 2. 以 下 正 确 的 说 法 是 D A. 实 参 和 与 其 对 应 的 形 参 各 占 用 独 立 的 存 储 单 元 B. 实 参 和 与 其 对 应 的 形 参 共 占 用 一 个 存 储 单 元 C. 只 有 当 实 参 和 与 其 对 应 的 形 参 同 名 时 才 共 占 用 相 同 的 存 储 单 元 D. 形 参 时 虚 拟 的, 不 占 用 存 储 单 元 3. 以 下 正 确 的 函 数 定 义 是 A A.double fun(int x, int y) B.double fun(int x ; int y) C.double fun(int x, int y) ; D.double fun(int x,y) 4. 有 以 下 函 数 定 义 : void fun(int n, double x), - 60

61 若 以 下 选 项 中 的 变 量 都 已 正 确 定 义 并 赋 值, 则 对 函 数 fun 的 正 确 调 用 语 句 是 C A.fun(int y,double m); B.k=fun(10,12.5); C.fun(x,n); D.void fun(n,x); 5.C 语 言 规 定, 函 数 返 回 值 的 类 型 是 由 D A.return 语 句 中 的 表 达 式 类 型 所 决 定 B. 调 用 该 函 数 时 的 主 调 函 数 类 型 所 决 定 C. 调 用 该 函 数 时 系 统 临 时 决 定 D. 在 定 义 该 函 数 时 所 指 定 的 函 数 类 型 决 定 6. 以 下 描 述 正 确 的 是 A A. 函 数 调 用 可 以 出 现 在 执 行 语 句 或 表 达 式 中 B. 函 数 调 用 不 能 作 为 一 个 函 数 的 实 参 C. 函 数 调 用 可 以 作 为 一 个 函 数 的 形 参 D. 以 上 都 不 正 确 7. 以 下 程 序 的 运 行 结 果 C #include <stdio.h> func(int a,int b) static int m=0,i=2; i+=m+1; m=i+a+b; return m; int k=4,m=1,p; p=func(k,m); printf("%d,",p); p=func(k,m); printf("%d",p); A. 8,8 B. 17,17 C. 8,17 D. 17,8 8. 若 使 用 一 维 数 组 名 作 函 数 实 参, 则 以 下 正 确 的 说 法 是 C A. 必 须 在 调 用 函 数 中 说 明 此 数 组 的 大 小 B. 实 参 数 组 类 型 与 形 参 数 组 类 型 可 以 不 匹 配 C. 在 被 调 用 函 数 中, 不 需 要 考 虑 形 参 数 组 的 大 小 D. 实 参 数 组 名 与 形 参 数 组 名 必 须 一 致 9. 下 面 程 序 的 运 行 结 果 是 B #include <stdio.h> void swap(int x,int y) int t; t=x;x=y;y=t; printf("%d,%d ",x,y); 61

62 int a=1,b=2; swap(a,b); printf("%d,%d\n",a,b); A. 1,2 1,2 B. 2,1 1,2 C. 2,1 2,1 D. 1,2 2,1 10. 如 下 程 序 : #include <stdio.h> max(int x,int y); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf(" a=%d,b=%d,max=%d\n ",a,b,c); int max(int x,int y) int z; if(x>y) z=x; else z=y; return(z); 运 行 时, 键 入 3,6 并 回 车, 可 得 到 结 果 是 A A. a=3,b=6,max=6 B.a=6,b=6,max=6 C. a=3,b=3,max=6 D. a=3,b=6,max=3 二 填 空 题 1. 函 数 中 的 形 参 和 调 用 时 的 实 参 都 是 数 组 时, 参 数 传 递 方 式 为 地 址 ; 都 是 普 通 变 量 时, 参 数 传 递 方 式 为 值 2. 若 自 定 义 函 数 要 求 要 求 返 回 一 个 值, 则 在 该 函 数 体 中 应 有 一 条 return 语 句 ; 若 自 定 义 函 数 要 求 不 返 回 值, 则 应 在 该 函 数 说 明 时 加 一 个 类 型 说 明 符 void 3. 以 下 程 序 的 运 行 结 果 是 4,fun 函 数 的 作 用 是 两 整 数 差 的 绝 对 值 #include <stdio.h> #include <math.h> fun(int y,int x) int z; z=fabs(x-y); return(z); int a=-1,b=-5,c; c=fun(a,b); 62

63 printf("%d",c); 3.. 在 函 数 调 用 语 句 fun(a+b,(x,y),fun(n+k,d,(a,b))); 中, 实 参 的 个 数 是 3 三 程 序 调 试 题 ( 下 列 各 程 序 中 存 在 一 些 问 题, 通 过 调 试 发 现 问 题, 并 加 以 修 正, 使 其 实 现 预 期 目 标 )) 1. 下 列 程 序 中,fun 函 数 的 功 能 是 : 根 据 形 参 m, 计 算 如 下 公 式 的 值 t=1+ 1/2 + 1/3 + 1/ /m 例 如, 若 输 入 5, 则 应 输 出 请 改 正 程 序 中 的 语 法 错 误, 使 程 序 能 得 出 正 确 的 结 果 #include<stdio.h> double fun(int m) double t=1.0; int i; for(i=2,i<=m,i++) t+=1.0/k; return t; int m; printf( nplease enter 1 integer number: ); scanf( %d,&m); printf( \nthe result is %d\n,fun(m)); 2. 下 列 给 定 程 序 中, 函 数 fun 的 功 能 是 : 计 算 并 输 出 k 以 内 最 大 的 10 个 能 被 13 或 17 整 除 的 自 然 数 之 和 k 的 值 由 主 函 数 传 入, 若 k 的 值 为 500, 则 函 数 值 为 4622 请 改 正 程 序 中 的 错 误, 使 程 序 能 得 出 正 确 的 结 果 #include <stdio.h> int fun(int k) int m=0, mc=0; while ((k>=2) (mc<10)) if ((k%13=0) (k%17=0)) m=m+k;mc++; k--; return k; printf("%d\n",fun(500)); 3. 下 列 程 序 的 功 能 为 : 输 入 4 个 整 数, 按 以 下 示 例 的 形 式 输 出 63

64 如 输 入 : 则 输 出 :( 第 一 行 为 输 入 数 字, 下 一 行 是 上 一 行 向 右 偏 移 一 个 数 字 ) 请 改 正 程 序 中 的 错 误, 并 上 机 调 试, 使 它 能 得 到 正 确 结 果 #include <stdio.h> void swap(int a[]) int i,temp=a[3]; for(i=3;i>=0;i--) a[i]=a[i-1]; a[0]=temp; int i,j,a[4]; for ( i = 0; i < 4; i++ ) scanf("%d",*a+i); for ( i = 0; i < 4; i++ ) for ( j = 0;j < 4; j++ ) printf( "%d ", a[j] ); printf( "\n"); swap(a[4]); 四 程 序 填 空 题 ( 请 填 写 适 当 的 符 号, 使 程 序 实 现 其 功 能 ) 1. 以 下 程 序 中 函 数 func 的 功 能 是 生 成 水 仙 花 数, 请 填 空 程 序 4.1 func (int n) int i,j,k; i=n/100; j=n/10-i*10 ; k= ; if ( return ; return ; main ( ) int n,k ; for (n=100; n<1000 ; n++) if (k= ) printf("%d",k) ; 2. 以 下 程 序 中 功 能 是 : 如 果 输 入 25, 则 输 出 25=5*5, 如 果 输 入 -36, 则 输 出 -36=-2*2*3*3, 请 填 空 64

65 程 序 4.2 #include <math.h> fun (int n) int k,r ; for (k=2; k<= ; k++) r = n % k ; while (!r) printf("%d",k); n=n/k; if (n>1) printf("*"); r = ; if (n!=1) printf("%d\n",n); main ( ) int n ; scanf("%d",&n); printf("%d=",n); if (n<0) printf("-"); n = ; ; 五 编 程 题 1. 编 写 一 个 函 数, 返 回 一 个 四 位 正 整 数 的 逆 序 数, 在 主 函 数 中 输 入 一 个 四 位 数, 例 如 6789, 输 出 它 的 逆 序 数 编 程 实 现 以 下 功 能 : 第 一 个 数 是 1, 从 第 二 个 数 起 每 个 数 都 是 它 的 前 一 项 加 5, 求 第 n 个 数 是 多 少?(n 从 键 盘 输 入, 用 递 归 的 方 法 实 现 该 算 法 ) 3. 编 写 函 数 实 现 如 下 功 能 : 从 3 个 红 球 (x) 5 个 白 球 (y) 6 个 黑 球 (z) 中 任 意 取 出 8 个, 且 其 中 必 须 要 有 红 球 和 白 球 请 编 写 函 数, 输 出 所 有 方 案 第 3 章 数 组 与 指 针 在 C 语 言 中, 数 组 和 指 针 是 两 个 极 为 重 要 的 知 识 点 数 组 作 为 构 造 数 据 类 型, 在 数 据 的 组 织 存 储 方 面 有 着 广 泛 的 应 用, 指 针 是 C 语 言 的 最 主 要 的 风 格 之 一, 灵 活 地 应 用 指 针 可 以 编 写 功 能 强 大 的 程 序 数 组 与 指 针 之 间 有 着 十 分 紧 密 的 联 系, 因 此, 熟 练 掌 握 数 组 指 针 的 相 关 知 识 点 十 分 重 要 除 了 基 本 类 型 的 数 据 外,C 语 言 还 提 供 了 构 造 类 型 的 数 据 如 数 组 类 型 构 造 体 类 型 和 公 用 体 类 型 数 据 数 组 类 型 是 比 较 简 单 的 构 造 类 型 数 组 是 有 序 数 据 的 集 合, 它 里 面 的 每 一 个 元 素 都 属 于 同 一 个 数 据 类 型, 并 且 用 一 个 统 一 的 数 组 名 和 下 标 来 唯 一 地 确 定 数 组 中 的 元 素 图 3-1 是 所 要 掌 握 的 数 组 基 本 知 识 结 构 65

66 一 维 数 组 的 定 义 一 维 数 组 一 维 数 组 的 初 始 化 一 维 数 组 元 素 的 引 用 二 维 数 组 的 定 义 二 维 数 组 二 维 数 组 的 初 始 化 数 组 字 符 数 组 数 组 作 函 数 参 数 二 维 数 组 元 素 的 引 用 字 符 数 组 的 定 义 字 符 数 组 的 初 始 化 字 符 数 组 元 素 的 引 用 字 符 串 与 字 符 数 组 的 区 别 与 联 系 字 符 串 ( 数 组 ) 输 入 输 出 函 数 gets puts 字 符 串 拼 接 函 数 strcat 常 用 字 符 串 处 理 函 数 字 符 串 拷 贝 函 数 strcpy 字 符 串 比 较 函 数 strcmp 字 符 串 长 度 函 数 strlen 数 组 元 素 作 函 数 参 数 数 组 名 作 函 数 参 数 图 3-1 数 组 基 本 知 识 结 构 66

67 3.1 一 维 数 组 一 维 数 组 的 定 义 一 维 数 组 的 定 义 方 式 : 类 型 说 明 符 数 组 名 [ 常 量 表 达 式 ]; 例 如 : int a[5]; 67

68 其 中 a 为 数 组 名,5 为 数 组 长 度 即 数 组 所 包 含 的 元 素 个 数 对 于 数 组 定 义 有 几 点 需 要 注 意 : 数 组 名 命 名 规 则 和 变 量 名 相 同 都 遵 循 标 识 符 命 名 规 则 数 组 名 后 的 表 达 式 常 量 是 用 方 括 号 括 起 来, 不 能 使 用 圆 括 弧 常 量 表 达 式 表 示 数 组 的 长 度, 如 int a[5]; 表 示 数 组 a 中 有 5 个 元 素, 下 标 应 该 从 0 开 始, 分 别 是 a[0],a[1],a[2],a[3], a[4], 注 意 不 能 使 用 数 组 元 素 a[5] 常 量 表 达 式 中 可 以 包 括 常 量 和 符 号 常 量, 不 能 包 含 变 量,C 不 允 许 对 数 组 的 大 小 作 动 态 定 义 如 int a[n]; n 如 果 是 变 量, 是 不 允 许 的 一 维 数 组 的 初 始 化 及 一 维 数 组 元 素 的 引 用 数 组 元 素 初 始 化, 即 给 数 组 元 素 赋 初 值, 可 以 通 过 几 种 不 同 的 方 式 : 在 定 义 数 组 时 对 数 组 元 素 赋 初 值 如 int a[5]=0,1,2,3,4; 将 数 组 元 素 的 初 值 依 次 放 在 一 对 大 括 弧 内 这 样 经 过 上 面 的 定 义 和 初 始 化 后, a[0]=0,a[1]=1,a[2]=2,a[3]=3,a[4]=4 只 给 一 部 分 元 素 赋 值 如 int a[5]=0,1,2; 数 组 a 定 义 时 包 含 5 个 元 素, 但 花 括 号 内 只 提 供 前 面 3 个 元 素 的 初 值, 后 2 个 元 素 值 则 为 0 若 一 个 数 组 中 全 部 元 素 值 都 为 0, 可 以 这 样 表 达, int a[5]=0,0,0,0,0; 或 int a[5]=0; 在 对 全 部 数 组 元 素 赋 初 值 时, 可 以 不 指 定 数 组 长 度 如 int a[5]=0,1,2,3,4; 可 以 写 成 int a[]=0,1,2,3,4; 但 若 被 定 义 的 数 组 长 度 与 提 供 初 值 的 个 数 不 相 同, 则 数 组 长 度 不 能 省 略 数 组 元 素 的 引 用 只 能 逐 个 引 用 数 组 元 素 而 不 能 一 次 引 用 整 个 数 组 数 组 元 素 的 表 示 形 式 为 : 数 组 名 [ 下 标 ], 其 中 下 标 可 以 是 整 型 常 量 或 整 型 表 达 式 如 a[1]=a[0]+a[3*4] 应 注 意 下 标 值 应 在 已 定 义 数 组 大 小 的 范 围 内 如 果 定 义 数 组 如 下 int a[5]; 但 元 素 赋 值 时 令 a[6]=6, 则 会 产 生 错 误, 因 为 a[6] 超 过 了 数 组 的 范 围 3.2 二 维 数 组 二 维 数 组 的 定 义 二 维 数 组 的 定 义 方 式 : 类 型 说 明 符 数 组 名 [ 常 量 表 达 式 ] [ 常 量 表 达 式 ]; 68

69 例 如 : int a[2][3]; 表 示 a 为 2 3 的 2 行 3 列 数 组, 数 组 长 度 为 6, 总 共 包 含 6 个 数 组 元 素 对 于 二 维 数 组 定 义 有 两 点 需 要 注 意 : 可 以 把 二 维 数 组 看 作 是 一 种 特 殊 的 一 维 数 组, 它 的 元 素 又 是 一 个 一 维 数 组 如 图 3-2 所 示, 当 把 数 组 a 看 成 是 一 个 一 维 数 组 时, 它 有 2 个 元 素 a[0],a[1], 每 个 元 素 又 是 包 含 3 个 元 素 的 一 维 数 组 a[0],a[1] 可 以 看 作 是 两 个 一 维 数 组 的 名 字 二 维 数 组 中 元 素 的 排 列 顺 序 是 按 行 存 放 的, 即 在 内 存 中 先 顺 序 存 放 第 一 行 的 元 素, 再 存 放 第 二 行 的 元 素 int a[2][3]; a a[0] a00 a01 a02 a[1] a10 a11 a12 图 3-3 二 维 数 组 二 维 数 组 的 初 始 化 及 二 维 数 组 元 素 的 引 用 二 维 数 组 元 素 初 始 化, 可 以 通 过 几 种 不 同 的 方 式 : 分 行 给 二 维 数 组 赋 初 值, 如 int a[2][3]=1,2,3,4,5,6; 这 种 方 法 比 较 直 观, 按 行 赋 初 值, 把 第 1 个 花 括 弧 内 的 数 据 给 第 1 行 元 素, 第 2 个 花 括 弧 内 的 数 据 赋 给 第 2 行 的 元 素 将 所 有 数 据 写 在 一 个 花 括 弧 内, 按 数 组 排 列 的 顺 序 对 元 素 赋 初 值 如 int a[2][3]=1,2,3,4,5,6; 对 部 分 元 素 赋 初 值 如 int a[2][3]=1,2,4; 其 只 对 第 1 行 的 1 2 列 元 素 及 第 2 行 的 第 1 个 元 素 赋 初 值, 其 余 元 素 值 为 0 对 全 部 数 组 元 素 赋 初 值, 则 定 义 数 组 时 对 第 一 维 的 长 度 可 以 不 指 定, 但 第 二 维 的 长 度 必 须 给 出 如 int a[2][3]=1,2,3,4,5,6; 可 以 写 成 int a[ ][3]=1,2,3,4,5,6; 系 统 会 根 据 总 个 数 分 配 存 储 空 间, 一 共 6 个 数 据, 每 行 3 个, 可 以 确 定 只 有 2 行 在 分 行 赋 初 值 时, 也 可 以 省 略 第 一 维 的 长 度, 只 对 部 分 元 素 赋 初 值 如 int a[][3]=1,2,4; 二 维 数 组 元 素 的 表 示 形 式 为 : 数 组 名 [ 下 标 ] [ 下 标 ], 其 中 下 标 可 以 是 整 型 常 量 或 整 型 表 达 式 如 a[1][1]=a[0][1]+a[4-3][1*2] 应 注 意 下 标 值 应 在 已 定 义 数 组 大 小 的 范 围 内 69

70 3.3 字 符 数 组 与 字 符 串 字 符 数 组 的 定 义 字 符 数 组 与 数 值 型 数 组 类 似, 只 是 数 组 中 存 放 的 数 据 是 字 符 型 数 据 在 字 符 数 组 中, 其 一 个 元 素 存 放 一 个 字 符 字 符 数 组 的 定 义 方 式 : 类 型 说 明 符 数 组 名 [ 常 量 表 达 式 ] 例 如 :char c[5]; 其 中 c 为 数 组 名,5 为 数 组 长 度 即 数 组 所 包 含 的 元 素 个 数 在 内 存 中 占 用 5 个 连 续 的 字 节 空 间 存 放 这 5 个 字 符 元 素 由 于 字 符 与 整 型 数 据 可 以 相 互 赋 值 关 系, 也 可 以 用 整 型 数 组 来 存 放 字 符 型 数 据, 虽 然 合 法, 但 浪 费 了 存 储 空 间 如 int c[5]; 在 内 存 空 间 中 要 分 配 10 个 连 续 的 字 节, 用 作 数 组 元 素 的 存 放 字 符 数 组 的 初 始 化 及 字 符 数 组 元 素 的 引 用 与 数 值 数 组 初 始 化 相 似, 字 符 数 组 初 始 化 有 如 下 方 式 : 逐 个 字 符 赋 给 数 组 中 各 元 素, 如 char c[5]= I,, o,, U ; 这 样 经 过 上 面 的 定 义 和 初 始 化 后,c[0]= I,c[1]=,c[2]= o,c[3]=,c[4]= U 这 种 初 始 化 方 式 要 注 意 花 括 号 中 字 符 个 数 要 小 于 或 等 于 数 组 长 度, 大 于 时, 则 编 译 时 会 出 现 语 法 错 误, 小 于 时, 字 符 数 组 的 其 余 元 素 自 动 定 义 为 空 字 符 ('\0 ) 在 初 始 化 时, 如 果 初 值 个 数 与 预 定 的 数 组 长 度 相 同, 可 以 省 略 数 组 长 度, 系 统 会 自 动 确 定 数 组 大 小 如 char c[]= I,, o,, U ; 二 维 字 符 数 组 定 义 和 初 始 化 与 数 值 型 数 组 基 本 相 同, 如 char cc[3][3]=, *,, *,, *,, *, ; 或 char cc[3][3]=, *,, *,, *,, *, ; 字 符 数 组 的 引 用 可 以 通 过 引 用 字 符 数 组 中 的 一 个 元 素 来 完 成, 如 main( ) char c[5]= I,, o,, U ; int i=2; printf( %c, c[i]); 这 里 是 引 用 c[2] 这 个 元 素, 将 其 值 输 出 在 终 端 上, 运 行 结 果 是, 在 终 端 上 输 出 字 符 o 字 符 串 在 C 语 言 中, 字 符 串 是 用 双 引 号 括 起 来, 以 字 符 数 组 形 式 在 内 存 中 存 放 的 因 而 在 字 符 数 组 的 初 始 化 时, 也 可 以 用 字 符 串 常 量 表 达, 如 70

71 char c[]= I o U ; 或 char c[]= I o U ; 但 是 此 时 数 组 c 的 长 度 不 是 5, 而 是 6 这 是 因 为 字 符 串 常 量 的 最 后 由 系 统 加 上 \0 作 为 结 束 符, 因 此 上 面 的 初 始 化 是 与 下 面 的 方 式 等 价 的 char c[]= I,, o,, U, \0 ; \0 代 表 ASCII 码 为 0 的 字 符, 它 不 是 一 个 可 以 显 示 的 字 符, 而 是 一 个 空 操 作 符, 即 它 什 么 也 不 干 用 它 来 作 为 字 符 串 结 束 标 志 不 会 产 生 附 加 的 操 作 或 增 加 有 效 字 符, 只 起 一 个 供 辨 别 的 标 志 与 字 符 串 不 同, 字 符 数 组 并 不 要 求 他 的 最 后 一 个 字 符 为 \0, 甚 至 也 可 以 不 包 含 \0, 如 下 面 定 义 是 完 全 正 确 的 char c[5]= I,, o,, U ; 字 符 数 组 的 输 入 输 出 字 符 数 组 的 输 入 输 出 有 两 种 方 法 : 用 格 式 符 %c, 逐 个 字 符 输 入 输 出, 如 main( ) char c[5]= I,, o,, U ; int i; for(i=0;i<=4;i++) printf( %c, c[i]); printf( \n ); // 逐 个 字 符 数 输 出 main( ) char c[5]; int i; for(i=0;i<=4;i++) scanf( %c, &c[i]); // 逐 个 字 符 数 输 入 用 格 式 符 %s, 将 整 个 字 符 串 输 入 输 出, 如 main( ) char c[]= I o U ; printf( %s, c); // 整 个 字 符 串 输 出 main( ) char c[5]; scanf( %s, c); // 整 个 字 符 串 输 入 对 字 符 数 组 在 使 用 输 入 输 出 语 句 时 需 要 注 意 以 下 几 点 : 整 个 字 符 数 组 输 入 时,scanf 函 数 中 的 输 入 项 是 字 符 数 组 名, 而 且 不 要 再 在 其 前 面 加 上 地 址 符 &, 因 为 数 组 名 在 C 语 言 中 代 表 了 该 数 组 的 起 始 地 址 如 char c[5]; 71

72 scanf( %s,&c); 是 错 的 整 个 字 符 数 组 输 出 时,prinf 函 数 中 的 输 出 项 是 字 符 数 组 名, 而 不 是 数 组 元 素 名 如 char c[]= I o U ; printf( %s, c[0]); 是 错 的 字 符 数 组 的 输 出 中 不 包 括 结 束 符 \0 如 果 字 符 数 组 中 包 含 一 个 以 上 的 \0, 则 遇 到 第 一 个 \0 时 输 出 结 束 用 scanf 函 数 输 入 多 个 字 符 串, 系 统 在 读 入 时, 如 果 遇 到 空 格, 则 认 为 一 个 字 符 串 输 入 完 毕, 继 续 读 取 下 一 个 字 符 串 处 理 函 数 C 语 言 的 函 数 库 中 提 供 了 一 些 用 来 处 理 字 符 串 的 函 数, 常 用 的 包 括 : puts 函 数, 格 式 为 :puts( 字 符 数 组 ), 其 作 用 是 将 一 个 字 符 串 ( 以 \0 结 束 的 字 符 序 列 ) 输 出 到 终 端 如 char c[]= I o U ; puts(c); 则 在 终 端 上 输 出 I o U gets 函 数, 格 式 为 :gets( 字 符 数 组 ), 其 作 用 是 从 终 端 输 入 一 个 字 符 串 到 字 符 数 组, 并 且 得 到 一 个 函 数 值, 该 值 是 字 符 数 组 的 起 始 地 址 如 char c[10]; gets(c); 从 终 端 键 盘 输 入 :china, 则 字 符 数 组 c 就 会 收 到 6 个 而 不 是 5 个 字 符 strcat 函 数, 格 式 为 :strcat( 字 符 数 组 1, 字 符 数 组 2), 其 作 用 是 将 字 符 数 组 2 中 的 字 符 串 接 到 字 符 数 组 1 中 的 字 符 串 后 面 ( 字 符 串 1 后 面 的 \0 取 消 ), 结 果 放 在 字 符 数 组 1 中, 函 数 调 用 后 得 到 一 个 函 数 值, 该 值 是 字 符 数 组 1 的 地 址 如 char c1[20]= I love ; char c2[]= china! ; printf( %s,strcat(c1,c2)); 终 端 上 输 出 的 结 果 是 :I love china!, 要 注 意 的 是 字 符 数 组 1 必 须 足 够 大, 比 便 容 纳 连 接 后 的 新 字 符 串 strcpy 函 数, 格 式 为 :strcpy( 字 符 数 组 1, 字 符 串 2), 其 作 用 是 将 字 符 串 2 复 制 到 字 符 数 组 1 中, 同 样 字 符 数 组 1 必 须 足 够 大, 比 便 容 纳 被 复 制 的 字 符 串 如 char c1[20], c2[]= china ; strcpy(c1,c2); 或 者 也 可 以 写 成 char c1[20]; strcpy(c1, china ); 注 意 在 复 制 时, 会 将 字 符 串 后 面 的 \0 一 起 复 制 到 前 面 的 字 符 数 组 中 strncpy 函 数, 格 式 为 :strncpy( 字 符 数 组 1, 字 符 串 2,n), 其 作 用 是 将 字 符 串 2 中 前 面 n 个 字 符 复 制 到 字 符 数 组 1 中, 取 代 字 符 数 组 1 中 最 前 面 的 n 个 字 符 如 char c1[]= I love ; 72

73 strncpy(c1, china!,2); printf( %s,c1); 终 端 的 输 出 结 果 是 :chlove strcmp 函 数, 格 式 为 :strcmp( 字 符 串 1, 字 符 串 2), 其 作 用 是 比 较 字 符 串 1 和 字 符 串 2 的 大 小, 结 果 是 返 回 一 个 函 数 值 如 果 两 字 符 串 相 等, 则 返 回 函 数 值 为 0; 字 符 串 1 大 于 字 符 串 2, 则 返 回 函 数 值 为 一 正 整 数 ; 字 符 串 1 小 于 字 符 串 2, 则 返 回 函 数 值 为 一 负 整 数 如 if(strcmp( China, America )>0) printf( ok ); 终 端 的 输 出 结 果 是 :ok 注 意 在 字 符 串 比 较 时, 对 两 个 字 符 串 是 自 左 至 右 逐 个 字 符 相 比 较, 比 较 的 是 其 ASCII 码 值 的 大 小, 直 到 出 现 不 同 的 字 符 或 遇 到 \0 为 止 若 全 部 字 符 相 同, 则 认 为 相 等 ; 若 出 现 不 相 同 的 字 符, 则 以 第 一 个 不 相 同 的 字 符 的 比 较 结 果 为 准 强 调 一 点 是, 对 于 字 符 串 的 比 较, 直 接 用 关 系 运 算 符 进 行 比 较 是 错 误 的, 如 if(c1==c2) printf( ok ); strlen 函 数, 格 式 为 :strlen( 字 符 数 组 ), 其 作 用 是 测 试 字 符 串 的 实 际 长 度, 结 果 返 回 值 为 不 包 括 结 尾 \0 在 内 的 字 符 串 的 实 际 长 度 如 char c1[20]= china! ; printf( %d,strlen(c1)); 终 端 输 出 结 果 是 6, 而 不 是 7 和 20 strlwr 函 数, 格 式 为 :strlwr( 字 符 串 ), 其 作 用 是 将 字 符 串 中 大 写 字 母 换 成 小 写 字 母 如 char c1[]= China ; strlwr(c1); printf( %s, c1); 终 端 输 出 结 果 是 :china strupr 函 数, 格 式 为 :strupr( 字 符 串 ), 其 作 用 是 将 字 符 串 中 小 写 字 母 换 成 大 写 字 母 如 char c1[]= China ; strupr(c1); printf( %s, c1); 终 端 输 出 结 果 是 :CHINA 3.4 数 组 作 为 函 数 参 数 数 组 元 素 作 函 数 参 数 数 组 元 素 可 以 作 为 函 数 的 实 参, 与 用 变 量 作 实 参 一 样, 是 单 向 传 递, 即 值 传 送 方 式 [ 数 组 元 素 作 函 数 参 数 案 例 ] 用 选 择 法 对 10 个 整 数 排 序, 并 将 最 大 值 输 出 /* 功 能 : 通 过 排 序 法 对 数 列 排 序, 并 输 出 最 大 值, 函 数 调 用 时 使 用 数 组 元 素 作 为 参 数 */ /* 选 择 法 : 其 思 想 是 假 定 有 10 个 数 a1,a2,,a10, 按 顺 序 从 a1 开 始, 将 a1 依 次 与 a2 至 a10 进 行 比 较, 若 a1 最 小, 则 不 作 任 何 操 作, 否 则 将 a2 至 a10 中 最 小 的 那 个 与 a1 互 换 值, 则 a1 就 存 放 了 a1 至 a10 中 的 最 小 值 ; 接 下 来 是 a2 与 a3 至 a10 进 行 比 较, 同 样 方 法, 依 次 73

74 类 推 进 行 排 序 */ void max(int a) Printf( %d, a); /* 输 出 最 大 值 */ int i, j, min, temp, a[11]; printf("enter data:\n"); for(i=1; i<=10; i++) printf("a[%d]=", i); scanf("%d", &a[i]); /* 输 入 10 个 数 */ printf("\n"); for(i=1; i<=10; i++) printf("%5d", a[i]); /* 输 出 这 10 个 数 */ printf("\n"); for(i=1; i<=9; i++) /* 对 10 个 数 排 序 */ min=i; for(j=i+1; j<=10; j++) if(a[min]>a[j]) min=j; temp=a[i]; a[i]=a[min]; a[min]=temp; max(a[10]); /* 函 数 调 用, 数 组 元 素 作 为 实 参 */ 数 组 名 作 函 数 参 数 数 组 名 也 可 以 作 为 函 数 参 数, 在 使 用 时 实 参 和 形 参 都 应 用 数 组 名 在 参 数 传 递 时, 不 是 把 数 组 的 值 传 递 给 形 参, 而 是 把 实 参 数 组 的 起 始 地 址 传 递 给 形 参 数 组, 使 两 个 数 组 共 占 同 一 段 内 存 单 元 数 组 名 作 函 数 参 数 在 使 用 时, 要 注 意 以 下 两 点 : 实 参 数 组 与 形 参 数 组 类 型 应 该 一 致, 否 则 结 果 将 会 出 错 形 参 数 组 可 以 不 指 定 大 小, 若 为 了 在 被 调 用 函 数 中 处 理 数 组 元 素 的 需 要, 可 以 另 设 一 个 参 数, 来 传 递 需 要 处 理 的 数 组 元 素 的 个 数 如 一 个 被 调 函 数 int count(float f[], int n) 这 里 用 形 参 n 来 确 定 形 参 数 组 f 的 元 素 个 数 多 维 数 组 名 作 为 函 数 调 用 的 实 参 和 形 参 时, 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 可 74

75 以 指 定 每 一 维 的 大 小, 也 可 以 省 略 第 一 位 的 大 小 说 明 但 其 他 维 的 大 小 说 明 不 能 省 略 如 二 维 数 组 作 为 函 数 参 数 使 用 时, 其 在 被 调 函 数 中 的 定 义 可 以 是 : int count(float f[2][3]); 或 者 int count(float f[][3]); [ 数 组 名 作 函 数 参 数 案 例 ] 在 统 计 学 生 的 成 绩 时, 如 果 发 现 平 均 分 低 于 75 分, 则 把 学 生 成 绩 进 行 如 下 处 理 : 用 成 绩 的 平 方 根 乘 以 10 来 提 高 分 数, 然 后, 再 计 算 平 均 分, 如 果 发 现 依 然 低 于 75 分, 则 继 续 用 上 述 方 法 来 处 理, 直 到 平 均 分 大 于 或 等 于 75 分 试 用 函 数 来 实 现 /* 功 能 : 设 计 一 统 计 分 数 程 序, 在 函 数 调 用 中, 使 用 数 组 名 作 为 函 数 参 数 */ #include <math.h> float avg; /* 全 局 变 量 */ void f1(float a[], int n) /* 求 平 均 分, 形 参 中 数 组 定 义 */ int i; float total=0; for (i=0;i<n;i++) total=total+a[i]; avg=total/n; f2(a,n); /* 函 数 调 用, 数 组 作 为 实 参 */ void f2(float a[], int n) /* 调 整 分 数, 形 参 中 数 组 定 义 */ int i; if (avg<75.0) for (i=0;i<n;i++) a[i]=sqrt(a[i])*10; f1(a,n); /* 函 数 调 用, 数 组 作 为 实 参 */ else printf("everyone's score is:\n"); for (i=0;i<n;i++) printf("%7.2f ", a[i]); printf("\nthe average score:%7.2f\n", avg); float score[5]; int i; for (i=0;i<5;i++) scanf("%f", &score[i]); f1(score,5); /* 函 数 调 用, 数 组 作 为 实 参 */ 75

76 3.5 指 针 指 针 基 本 概 念 计 算 机 对 变 量 是 依 据 其 数 据 类 型 来 分 配 具 体 的 内 存 地 址 的 由 于 各 类 变 量 所 占 的 字 节 数 不 同, 为 了 便 于 寻 址, 计 算 机 用 首 地 址 来 表 示 整 个 变 量 的 地 址, 所 谓 首 地 址 是 指 变 量 所 占 字 节 中 的 最 低 地 址 (1) 指 针 与 指 针 变 量 的 区 别 变 量 在 内 存 中 分 配 得 到 的 位 置 叫 变 量 的 地 址, 即 指 针 存 储 另 一 个 变 量 的 地 址 的 变 量, 则 叫 指 针 变 量, 指 针 变 量 是 通 过 寻 址 去 找 另 一 个 变 量 的 (2) 指 针 变 量 的 访 问 指 针 变 量 的 访 问 有 直 接 访 问 与 间 接 访 问, 前 者 是 按 变 量 地 址 存 取 变 量 值, 后 者 是 通 过 存 放 变 量 地 址 的 变 量 ( 如 指 针 ) 去 访 问 变 量 (3) 指 针 变 量 定 义 形 式 指 针 变 量 定 义 形 式 为 : [ 存 储 类 型 ] 数 据 类 型 * 指 针 名 ; (4) 指 针 变 量 的 初 始 化 指 针 变 量 的 初 始 化 为 : [ 存 储 类 型 ] 数 据 类 型 * 指 针 名 = 初 始 地 址 值 ; 指 针 常 见 的 运 算 (1) 指 针 变 量 被 赋 值, 可 改 变 指 针 的 指 向, 使 指 针 指 向 一 个 具 体 的 对 象, 从 而 操 作 该 对 象 参 与 运 算 (2) 指 针 的 移 动, 是 指 对 指 针 变 量 进 行 加 上 或 减 去 一 个 整 数, 或 者 通 过 赋 值, 使 指 针 变 量 指 向 其 他 的 存 储 单 元 前 者 也 就 是 对 地 址 进 行 增 减 运 算 指 针 移 动 的 最 小 单 元 是 一 个 存 储 单 元, 而 不 是 一 个 字 节 (3) 引 用 指 针 变 量 的 值, 运 用 取 地 址 运 算 符 & ( 引 用 当 前 所 指 的 地 址 ) (4) 引 用 指 针 所 指 的 变 量 的 值, 运 用 指 针 运 算 符 * ( 引 用 当 前 所 指 的 地 址 的 内 容 ) (5) 比 较 两 个 同 类 型 的 指 针 的 值 是 否 相 等, 只 有 当 两 个 或 多 个 指 针 指 向 同 一 个 目 标 时, 比 较 才 有 意 义 (6) 求 两 指 针 变 量 的 差 ( 两 个 指 针 所 指 位 置 间 相 差 的 元 素 个 数 ) 指 针 与 数 组 的 关 系 (1) 指 针 变 量 可 指 向 数 组, 也 可 指 向 数 组 元 素 也 就 是 把 数 组 的 起 始 地 址 或 一 个 元 素 的 地 址 赋 值 给 指 针 变 量 如 : int a[10],*p; p=a; 或 者 p=&a[0]; (2) 数 组 元 素 表 示 方 法 : 引 用 数 组 元 素 可 以 用 下 标 法, 如 a[3], 也 可 以 用 指 针 法, 即 通 过 指 向 数 组 元 素 的 指 针 找 到 所 需 的 元 素, 如 int a[10],*p; p=a; 76

77 (3) 一 维 数 组 的 数 组 名, 就 是 一 个 一 级 指 针, 指 向 数 组 的 第 一 个 元 素 如 int a[5]; a 是 一 级 指 针, 存 放 a[0] 在 内 存 的 地 址 (4) 数 组 名 是 指 针 ( 地 址 ) 常 量, 表 示 数 组 的 首 地 址, 即 array[0] 的 地 址 ;p=q; 则 p+i 是 q[i] 的 地 址 ;q[i] 等 价 于 *(p+i); (5) 二 维 数 组 地 址 表 示, 如 int a[3][4]; 1) a 二 维 数 组 的 首 地 址, 即 第 0 行 的 首 地 址 2) a+i 表 示 第 i 行 的 首 地 址 3) a[i] 等 价 于 *(a+i) 表 示 第 i 行 第 0 列 的 元 素 地 址 4) a[i]+j, 等 价 于 *(a+i)+j, 等 价 于 &a[i][j] 表 示 第 i 行 第 j 列 的 元 素 地 址 (6) 通 过 地 址 来 引 用 二 维 数 组 元 素 有 如 下 几 种 方 法, 例 如 int a[3][4],i,j; a[i][j] (a[i]+j) 数 组 的 基 类 型 是 int, 故 j 移 动 的 字 节 数 为 2*j 字 节 *(*(a+i)+j) *(*(a+i))[j] *(&a[0][0]+4*i+j) 指 向 一 维 数 组 的 指 针 变 量 指 向 一 维 数 组 的 指 针 变 量, 即 数 组 指 针 如 :int (*p)[3]; 定 义 格 式 : 数 据 类 型 (* 指 针 名 )[ 一 维 数 组 维 数 ]; 可 以 使 数 组 指 针 指 向 二 维 数 组 中 某 一 行 如 int a[3][4], (*p)[4]=a; 但 数 组 指 针 变 量 的 维 数 和 其 指 向 的 二 维 数 组 列 数 必 须 相 同 数 组 指 针 与 二 维 数 组 元 素 的 引 用 关 系 如 下 : 1) p=a+i 使 p 指 向 二 维 数 组 的 第 i 行 2) *(*(p+i)+j) 表 示 引 用 a[i][j] 这 个 元 素 内 容 3) (*(p+i)+j) 表 示 引 用 a[i][j] 的 地 址 指 针 数 组 指 针 数 组 指 的 是 数 组 的 元 素 都 是 指 针, 形 成 指 针 阵 列, 分 别 指 向 同 一 种 类 型 的 变 量, 常 用 于 指 向 多 个 字 符 串 如 :int *p[3]; 定 义 格 式 : [ 存 储 类 型 ] 数 据 类 型 * 数 组 名 [ 数 组 长 度 说 明 ]; 指 针 与 函 数 (1) 在 C 语 言 中, 函 数 名 代 表 函 数 执 行 时 的 入 口 地 址 当 把 函 数 名 赋 予 指 针 变 量 时, 该 指 针 称 为 指 向 函 数 的 指 针, 简 称 函 数 指 针, 指 针 变 量 的 内 容 就 是 该 函 数 代 码 段 的 入 口 地 址 (2) 指 针 变 量 作 为 函 数 的 参 数, 其 作 用 是 将 一 个 变 量 的 地 址 传 送 到 另 一 个 函 数 中 这 种 参 数 传 递 方 式 是 双 向 传 递, 又 称 为 地 址 传 递 区 别 于 单 向 传 递 的 值 传 递 77

78 (3) 当 函 数 的 形 参 为 指 针 变 量 时, 函 数 调 用 时 的 实 参 必 须 是 基 类 型 相 同 的 地 址 值 或 是 已 指 向 某 个 存 储 单 元 的 指 针 变 量 通 过 传 送 地 址 值, 可 以 在 被 调 用 函 数 中 对 调 用 函 数 中 的 变 量 进 行 引 用 (4) 使 用 指 针 在 理 论 上 可 对 内 存 地 址 里 的 内 容 随 意 变 更, 利 用 这 一 特 性, 往 往 将 指 针 变 量 作 为 函 数 的 实 参 (5) 指 针 变 量 可 以 用 函 数 malloc 向 内 存 堆 栈 申 请 空 间, 用 函 数 free 释 放 申 请 内 存 空 间 3.6 典 型 案 例 分 析 1. 一 个 数 组 究 竟 要 占 用 多 少 内 存? [ 分 析 ] 数 组 与 变 量 一 样 都 是 用 于 存 放 数 据 的, 所 以 同 样 需 要 占 用 一 定 内 存 空 间 一 个 数 组 被 定 义 后, 系 统 将 在 内 存 中 为 它 分 配 一 块 连 续 的 内 存 空 间, 内 存 空 间 的 大 小 为 元 素 个 数 *sizeof( 数 据 类 型 ) 含 有 n 个 (n 为 数 组 长 度 ) 存 储 单 元 的 存 储 空 间, 每 个 存 储 单 元 的 字 节 数 等 于 元 素 类 型 的 长 度 例 如 : 如 果 在 32 位 机 环 境 下, 定 义 一 个 含 有 10 个 int 型 元 素 的 一 维 数 组, 它 共 占 用 10 4=40 个 字 节 的 存 储 空 间 2. 若 有 数 组 a, 则 a 代 表 什 么?&a[1]-&a[0]=? [ 分 析 ] 一 个 数 组 占 用 一 段 连 续 的 内 存, 其 第 一 个 字 节 的 位 置 为 数 组 的 首 地 址 数 组 名 a 代 表 了 数 组 的 首 地 址 数 组 中 包 含 了 若 干 个 元 素, 每 个 元 素 相 当 于 一 个 普 通 变 量 下 面 的 程 序 能 够 展 示 出 数 组 在 内 存 中 的 占 用 情 况 int a[3]; printf("a 的 地 址 是 %d\n",a); printf("a[0] 的 地 址 是 %d\n",&a[0]); printf("a[1] 的 地 址 是 %d\n",&a[1]); printf("a[2] 的 地 址 是 %d\n",&a[2]); 可 能 输 出 结 果 是 : a 的 地 址 是 a[0] 的 地 址 是 a[1] 的 地 址 是 a[2] 的 地 址 是 由 此, 可 以 看 出 输 出 数 组 名 实 际 上 输 出 的 是 一 个 地 址, 这 个 地 址 与 数 组 的 第 一 个 元 素 a[0] 的 地 址 是 相 同 的 &a[1]-&a[0]= =4, 表 示 数 组 元 素 a[0] 占 用 4 个 字 节 数 组 元 素 占 用 内 存 数 与 其 数 据 类 型 有 关, 若 数 组 a 是 char, 则 a[0] 占 用 的 字 节 数 将 为 1 3. 为 什 么 数 组 名 必 须 是 常 量? [ 分 析 ] 数 组 元 素 在 内 存 中 的 地 址 可 以 通 过 数 组 的 首 地 址 及 下 标 计 算 得 到 下 标 为 i 的 数 组 元 素 a[i] 的 存 储 地 址 loc(a[i]) 为 :loc(a[i])=loc(a[0])+i*k, 其 中 每 个 数 组 元 素 占 k 个 存 储 单 元, loc(*) 表 示 取 得 某 一 元 素 的 地 址,i=0,1,2,,n-1 若 首 地 址 被 任 意 修 改, 则 数 组 中 每 个 元 素 在 内 存 中 的 地 址 无 从 得 知, 从 而 无 法 再 对 数 组 元 素 中 的 值 进 行 读 写 因 此,C 语 言 中 的 数 组 名 必 须 是 常 量, 一 切 试 图 修 改 数 组 首 地 址 的 操 作 都 是 不 合 法 的 78

79 4. strlen 与 sizeof 有 什 么 区 别? [ 分 析 ] sizeof 是 一 个 操 作 符, 它 以 字 节 形 式 给 出 其 操 作 数 所 占 存 储 大 小 strlen 是 一 个 函 数, 用 于 返 回 字 符 数 组 的 实 际 长 度 如 下 面 的 例 子 : char st[20] = "hel\0t"; printf("%d,%d\n",strlen(st),sizeof(st)); 程 序 的 运 行 结 果 是 :3,20 程 序 中 定 义 了 一 个 包 含 20 个 元 素 的 字 符 数 组 st, 每 个 元 素 占 1 个 字 节, 则 整 个 数 组 占 20 个 字 节, 所 以 sizeof(st) 为 20 strlen() 函 数 返 回 的 是 转 义 字 符 '\0' 之 前 的 字 符 个 数, 所 以 strlen(st) 为 3 5. 若 有 定 义 char s[] = "well"; char t[]='w', 'e', 'l', 'l'; 则 s 与 t 相 同 吗? [ 分 析 ] s 和 t 是 不 同 的 虽 然 这 两 种 字 符 数 组 初 始 化 方 式 都 是 合 法 的, 但 两 者 产 生 的 结 果 并 不 同 若 使 用 printf 的 "%s" 格 式 分 别 输 出 两 个 数 组 时,s 的 值 能 够 正 确 输 出, 但 输 出 t 时 将 会 出 现 乱 码 原 因 是 s 被 赋 予 了 整 个 字 符 串, 其 中 包 括 字 符 串 结 束 符 '\0' t 被 逐 个 赋 值, 数 组 中 不 包 括 字 符 串 结 束 符 '\0' 为 了 使 t 能 够 正 常 输 出, 须 对 t 的 初 始 化 语 句 修 改 如 下 : char t[] = 'w', 'e', 'l', 'l', '\0'; 6. 以 下 叙 述 中 错 误 的 是 A. 对 于 double 类 型 的 数 组, 不 可 以 直 接 用 数 组 名 对 数 组 进 行 整 体 输 入 或 输 出 B. 数 组 名 代 表 的 是 数 组 所 占 存 储 区 的 首 地 址, 其 值 不 可 改 变 C. 当 程 序 执 行 中, 数 组 元 素 的 下 标 超 出 所 定 义 的 下 标 范 围 时, 系 统 将 给 出 下 标 越 界 的 出 错 信 息 D. 可 以 通 过 赋 初 值 的 方 式 确 定 数 组 元 素 的 个 数 分 析 答 案 为 C 本 题 考 核 的 是 数 组 的 基 本 概 念 在 C 语 言 中, 除 字 符 数 组 外, 一 个 数 组 不 能 通 过 数 组 名 对 数 组 进 行 整 体 引 用, 因 此 选 项 A 正 确 数 组 名 中 存 放 的 是 一 个 地 址 常 量, 它 代 表 整 个 数 组 的 首 地 址, 因 此 选 项 B 正 确 C 语 言 程 序 在 运 行 过 程 中, 系 统 不 自 动 检 验 数 组 元 素 的 下 标 是 否 越 界, 因 此 选 项 C 错 误 C 语 言 规 定 可 以 通 过 赋 初 值 来 定 义 数 组 的 大 小, 这 时 数 组 说 明 符 的 一 对 方 括 号 中 可 以 不 指 定 数 组 的 大 小, 因 此 选 项 D 正 确 7. 以 下 能 正 确 定 义 一 维 数 组 的 选 项 是 A. int num[]; B. #define N 100 int num[n]; C. int num[0..100]; D. int N=100; int num[n]; 分 析 答 案 为 B 本 题 考 核 的 知 识 点 是 一 维 数 组 的 定 义 选 项 A 定 义 数 组 时 省 略 了 长 度, 而 C 语 言 中 规 定, 只 有 在 定 义 并 同 时 进 行 初 始 化 时, 数 组 的 长 度 才 可 以 省 略, 数 组 的 长 度 为 初 始 化 时 候 的 成 员 个 数, 故 选 项 A 错 误 在 C 语 言 中 规 定, 数 组 的 长 度 必 须 是 一 个 整 数 或 整 型 常 量 表 达 式, 故 选 项 C 错 误 定 义 时 数 组 的 长 度 不 能 使 用 变 量 表 示, 故 选 项 D 错 误 因 此, 选 项 B 符 合 题 意 8. 若 有 定 义 :int aa[8]; 则 以 下 表 达 式 中 不 能 代 表 数 组 元 素 aa[1] 的 地 址 的 是 A. &aa[0]+1 B. &aa[1] C. &aa[0]++ D. aa+1 分 析 答 案 为 C 本 题 考 核 的 知 识 点 是 数 组 中 元 素 地 址 的 表 示 方 法 在 C 语 言 中 数 组 的 地 址 和 数 组 中 第 一 个 元 素 的 地 址 相 同 数 组 中 第 一 个 元 素 地 址 的 表 示 方 法 为 &aa[0], 与 其 79

80 等 价 的 有 &aa[0]++, 所 以 选 项 C 不 正 确 选 项 A 为 数 组 的 第 一 个 元 素 的 地 址 下 移 一 位 即 是 第 二 个 元 素 a[1] 的 地 址 ;B 也 为 数 组 的 第 二 个 元 素 的 地 址 ; 选 项 D 中 aa 表 示 数 组 的 地 址, 加 1 表 示 数 组 首 地 址 后 移 一 位, 即 代 表 数 组 元 素 中 的 第 二 个 元 素 aa[1] 的 地 址 9. 假 定 int 类 型 变 量 占 用 两 个 字 节, 若 有 定 义 int x[10]=0,2,4;, 则 数 组 x 在 内 存 中 所 占 的 字 节 数 是 A. 3 B. 6 C. 10 D. 20 分 析 答 案 为 D 本 题 考 核 的 知 识 点 是 C 语 言 中 数 组 在 内 存 中 占 据 的 字 节 个 数 本 题 数 组 x 有 10 个 元 素, 每 个 元 素 在 内 存 中 占 2 个 字 节, 所 以 数 组 x 在 内 存 中 共 占 10*2=20 个 字 节, 与 数 组 的 初 值 个 数 无 关 10. 以 下 能 正 确 定 义 二 维 数 组 的 是 A. int a[][3]; B. int a[][3]=2*3; C. int a[][3]=; D. int a[2][3]=1,2,3,4 分 析 答 案 为 B 本 题 考 核 的 知 识 点 是 二 维 数 组 的 定 义 选 项 A 中 省 略 了 第 一 维 的 长 度, 在 C 语 言 中 是 不 允 许 的 ; 选 项 C 也 是 省 略 了 第 一 维 的 长 度 ; 选 项 D 中 定 义 了 一 个 2 行 3 列 的 数 组, 而 在 赋 值 的 时 候 去 赋 了 一 个 3 行 的 值 给 它, 显 然 是 不 正 确 的 所 以 选 项 B 符 合 题 意 11. 有 以 下 程 序 int m[][3]=1,4,7,2,5,8,3,6,9; int i, j, k=2; for(i=0;i<3;i++) printf("%d ", m[k][i]); 执 行 后 输 出 的 结 果 是 A B C D 分 析 答 案 为 C 本 题 考 核 的 知 识 点 是 二 维 数 组 的 定 义 赋 值 以 及 数 组 元 素 的 引 用 变 量 k 的 初 值 位 2, 循 环 执 行 了 3 次, 分 别 输 出 m[2][0] m[2][1] 和 m[2][2], 其 值 分 别 为 所 以,C 选 项 为 所 选 12. 以 下 程 序 的 输 出 结 果 是 int a[4][4]=1,3,5,2,4,6,3,5,7; printf("%d%d%d%d\n", a[0][3],a[1][2] a[2][1] a[3][0]); A B C D. 输 出 值 不 确 定 分 析 答 案 为 A 本 题 考 核 的 知 识 点 是 二 维 数 组 的 定 义 及 其 初 始 化 二 维 数 组 在 内 存 中 是 按 行 优 先 的 顺 序 存 放 的, 数 组 a 初 始 化 后 a[0][0]=1 a[0][1]=3 a[0][2]=5 a[0][3]=0 a[1][0]=2 a[1][1]=4 a[1][2]=6 a[1][3]=0 a[2][0]=3 a[2][1]=5 a[2][2]=7 a[2][3]=0 a[3][0]=0 a[3][1]=0 a[3][2]=0 a[3][3]=0 13. 以 下 不 能 正 确 进 行 字 符 串 赋 初 值 的 语 句 是 A. char str[5]= "good!"; B. char str[]= "good!"; C. char *str= "good!"; D. char str[5]= 'g', 'o', 'o', 'd'; 分 析 答 案 为 A 本 题 考 核 的 知 识 点 是 字 符 串 的 赋 值 问 题 选 项 A 定 义 了 一 个 字 符 数 80

81 组 str, 具 有 5 个 元 素, 但 赋 初 值 的 时 候, 初 值 个 数 却 是 6 个 ( 有 一 个 '\0'), 故 选 项 A 错 误 ; 选 项 B 定 义 了 一 个 字 符 数 组 str 并 给 它 赋 初 值, 由 于 省 去 了 长 度 定 义, 长 度 由 初 值 个 数 确 定, 相 当 于 str[6], 选 项 B 正 确 ; 选 项 C 定 义 了 一 个 字 符 型 指 针 变 量 并 用 一 个 字 符 串 给 它 赋 初 值, 使 该 字 符 型 指 针 指 向 了 该 字 符 串, 选 项 C 正 确 ; 选 项 D 是 对 字 符 型 数 组 中 单 个 元 素 依 次 赋 初 值, 选 项 D 正 确 所 以, 选 项 A 为 所 选 14. 已 有 定 义 : char a[]="xyz",b[]='x', 'y','z';, 以 下 叙 述 中 正 确 的 是 A. 数 组 a 和 数 组 b 的 长 度 相 同 B. a 数 组 的 长 度 小 于 b 数 组 的 长 度 C. a 数 组 的 长 度 大 于 b 数 组 的 长 度 D. 上 述 说 法 都 不 对 分 析 答 案 为 C 本 题 考 核 的 知 识 点 是 字 符 数 组 的 初 始 化 对 字 符 数 组 在 定 义 时 初 始 化, 既 可 以 使 用 初 始 化 列 表, 也 可 以 使 用 字 符 串 常 量 不 过 由 于 字 符 串 常 量 会 自 动 在 结 尾 添 加 '\0' 字 符 作 结 束 标 志, 所 以 字 符 串 常 量 的 初 始 化 列 表 项 个 数 是 字 符 串 的 长 度 加 1 因 此 题 目 中 的 char a[]="xyz" 等 价 于 char a[]='x', 'y','z','\0' 所 以 数 组 a 的 长 度 大 于 数 组 b 的 长 度 15. 以 下 程 序 的 输 出 结 果 是 char ch[3][5]="aaaa", "BBB", "CC"; printf("\"%s\"\n", ch[1]); A. "AAAA" B. "BBB" C. "BBBCC" D. "CC" 分 析 答 案 为 B 本 题 考 核 的 知 识 点 是 二 维 字 符 数 组 的 应 用 二 维 字 符 数 组 可 以 看 成 由 若 干 个 一 维 字 符 数 组 组 成, 每 行 是 一 个 一 维 字 符 数 组 本 题 首 先 定 义 了 一 个 数 组 ch[3][5], 并 给 它 们 按 行 赋 初 值, 即 相 当 于 给 ch[0] 赋 值 "AAAA", 给 ch[1] 赋 值 "BBB", 给 ch[2] 赋 值 "CC", 最 后 输 出 转 义 字 符 \" ch[1] 和 转 义 字 符 \", 因 此 输 出 为 "BBB" 16. 有 以 下 程 序 char a[7]= "a0\0a0\0"; int i, j; i=sizeof(a); j=strlen(a); printf("%d %d", i, j); 程 序 运 行 后 输 出 结 果 是 A. 2 2 B. 7 6 C. 7 2 D. 6 2 分 析 答 案 为 C 本 题 考 核 的 知 识 点 是 C 语 言 中 数 组 长 度 和 字 符 串 长 度 数 组 长 度 是 指 一 个 数 组 所 占 内 存 空 间 的 字 节 数, 数 组 长 度 可 以 通 过 sizeof(< 数 组 名 >) 来 求 得 ; 字 符 串 长 度 是 指 从 指 定 内 存 地 址 开 始 直 到 碰 到 第 一 个 '\0' 字 符 为 止 所 经 过 的 字 符 数 ( 不 包 括 '\0' 字 符 ), 字 符 串 长 度 可 以 通 过 字 符 串 函 数 strlen(< 字 符 串 首 地 址 值 >) 来 求 得 所 以 本 题 程 序 运 行 后, 变 量 i 中 是 数 组 a 的 长 度 7, 变 量 j 中 是 数 组 a 中 第 一 个 '\0' 字 符 之 前 的 字 符 数 2 选 项 C 符 合 题 意 17. 以 下 程 序 执 行 后 的 输 出 结 果 是 char arr[2][4]; strcpy(arr, "you"); strcpy(arr[1], "me"); 81

82 arr[0][3]= '&'; printf("%s \n", arr); A. you&me B. you C. me D. err 分 析 答 案 为 A 本 题 考 核 的 知 识 点 是 库 函 数 strcpy 的 应 用 程 序 中 的 二 维 字 符 数 组 arr 可 以 存 放 两 行 字 符 串, 每 行 字 符 串 的 长 度 不 能 大 于 3 执 行 语 句 strcpy(arr, "you") 后, 数 字 arr 中 存 放 的 字 符 串 是 "you\0"; 执 行 语 句 strcpy(arr[1], "me") 后, 数 组 arr 中 存 放 的 字 符 串 是 "you\0me\0"; 执 行 语 句 arr[0][3]= '&' 后, 数 组 arr 中 存 放 的 字 符 串 是 "you&me\0", 所 以 语 句 的 输 出 结 果 为 you&me 18. s1 和 s2 已 正 确 定 义 并 分 别 指 向 两 个 字 符 串 若 要 求 : 当 s1 所 指 串 大 于 s2 所 指 串 时, 执 行 语 句 S 则 以 下 选 项 中 正 确 的 是 A. if(s1>s2) S; B. if(strcmp(s1,s2)) S; C. if(strcmp(s2,s1)>0) S; D. if(strcmp(s1,s2)>0) S; 分 析 答 案 为 D 本 题 考 核 的 知 识 点 是 字 符 串 的 比 较 在 C 语 言 中 字 符 串 的 比 较 用 strcmp() 函 数, 该 函 数 有 两 个 参 数, 分 别 为 被 比 较 的 两 个 字 符 串 如 果 第 一 个 字 符 串 大 于 第 二 个 字 符 串, 则 返 回 值 大 于 0, 若 小 于 第 二 个 字 符 串, 则 返 回 值 小 于 0, 若 等 于 第 二 个 字 符 串, 则 返 回 值 为 0 字 符 串 比 较 大 小 的 标 准 是 从 第 一 个 字 符 开 始 依 次 向 右 比 较, 遇 到 某 一 字 符 大, 该 字 符 所 在 的 字 符 串 就 是 较 大 的 字 符 串, 如 果 遇 到 某 一 个 字 符 小, 该 字 符 所 在 的 字 符 串 就 使 较 小 的 字 符 串 本 题 中 要 求 当 s1 所 指 字 符 串 大 于 s2 所 指 串 时, 执 行 语 句 s, 因 此 应 该 为 strcmp(s1,s2)>0 或 者 strcmp(s2,s1)<0, 所 以,4 个 选 项 中 D 符 合 题 意 19. 以 下 关 于 C 语 言 中 数 组 的 描 述 正 确 的 是 A. 数 组 的 大 小 是 固 定 的, 但 可 以 有 不 同 类 型 的 数 组 元 素 B. 数 组 的 大 小 是 可 变 的, 但 所 有 数 组 元 素 的 类 型 必 须 相 同 C. 数 组 的 大 小 是 固 定 的, 所 有 数 组 元 素 的 类 型 必 须 相 同 D. 数 组 的 大 小 是 可 变 的, 可 以 有 不 同 类 型 的 数 组 元 素 分 析 答 案 为 C 数 组 是 具 有 相 同 类 型 的 数 据 的 集 合, 在 C 语 言 中 规 定 数 组 的 大 小 是 固 定 的 所 以 选 项 C 是 正 确 的 20. 当 接 受 用 户 输 入 的 含 空 格 的 字 符 串 时, 应 使 用 函 数 A. scanf() B. gets() C. getchar() D. getc() 分 析 答 案 为 B 上 述 四 个 选 项 中 只 有 scanf() 和 gets() 能 够 接 受 用 户 输 入 的 字 符 串 scanf() 函 数 以 空 格 表 示 输 入 结 束, 而 gets() 函 数 能 够 接 受 用 户 输 入 的 含 空 格 的 字 符 串 所 以 选 项 B 是 正 确 的 答 案 21. 以 下 程 序 语 句 输 出 的 结 果 是 printf("%d\n",strlen("ast\n012\1\\")); A. 11 B. 10 C. 9 D. 8 分 析 答 案 为 C 因 为 字 符 串 "AST\n012\1\\" 中,'\n' 是 一 个 字 符,'\1' 是 一 个 字 符,'\\' 也 是 一 个 字 符 ( 即 '\', 第 一 个 反 斜 杠 是 转 义 字 符 ), 所 以 该 字 符 串 的 长 度 是 9 因 此 本 题 答 案 为 C 22. 有 以 下 程 序 段 char str[14]="i am "; strcat(str, "sad!"); scanf("%s",str); 82

83 printf("%s",str); 当 输 入 为 happy! 时, 程 序 运 行 后 输 出 结 果 是 A. I am sad! B. happy! C. I am happy! D. happy!sad! 分 析 答 案 为 B strcat 的 功 能 是 连 接 两 个 字 符 串, 此 时 字 符 串 的 长 度 为 9, 虽 然 用 scanf 语 句 输 入 的 字 符 串 只 有 6 个 字 符, 但 由 于 系 统 自 动 加 上 了 '\0' 标 志, 所 以 原 字 符 串 中 未 被 覆 盖 的 部 分 并 不 会 被 输 出 因 此, 选 项 B 是 正 确 的 23. 若 有 定 义 float y[5]=1,2,3;, 则 下 列 描 述 正 确 的 是 A. y 并 不 代 表 数 组 的 元 素 B. 定 义 此 数 组 时 不 指 定 数 组 的 长 度, 定 义 效 果 相 同 C. 数 组 含 有 3 个 元 素 D. y[3] 的 值 为 3 分 析 答 案 为 A y 是 数 组 名, 代 表 了 数 组 的 首 地 址, 并 不 能 代 表 数 组 的 某 个 元 素, 所 以 答 案 A 正 确 语 句 float y[5]=1,2,3; 和 float y[]=1,2,3; 的 定 义 效 果 是 不 同 的, 前 者 定 义 了 一 个 包 含 5 个 元 素 的 数 组, 但 只 有 3 个 元 素 被 赋 了 初 值 而 后 者 定 义 的 是 1 个 只 包 含 3 个 元 素 的 数 组, 数 组 元 素 个 数 是 由 初 始 化 列 表 中 初 值 的 个 数 决 定 的 所 以 选 项 B 不 正 确 数 组 y 是 一 个 包 含 5 个 元 素 的 数 组, 所 以 答 案 C 不 正 确 数 组 的 下 标 是 从 0 开 始, 第 3 个 元 素 的 下 标 为 2, 所 以 a[2] 的 值 为 以 下 程 序 的 输 出 结 果 是 int z,y[3]=2,3,4; y[y[2]]=10; printf("%d",z); A. 10 B. 2 C. 3 D. 运 行 时 出 错, 得 不 到 值 分 析 答 案 为 D 虽 然 数 组 元 素 y[2] 的 值 为 4, 所 以 y[y[2]] 相 当 于 y[4], 数 组 y 的 合 法 下 标 是 0 1 2, 所 以 访 问 y[4] 时, 出 现 了 下 标 越 界 现 象, 运 行 时 出 错 因 此 本 题 答 案 为 D 25. 定 义 如 下 变 量 和 数 组 : int i; int x[3][3]=1,2,3,4,5,6,7,8,9; 则 以 下 语 句 的 输 出 结 果 是 for(i=0;i<3;i++) printf("%d",x[i][2-i]); A B C D 分 析 答 案 为 C 二 维 数 组 初 始 化 后 有 : 对 于 for 循 环, 当 i=0 时, 输 出 x[0][2] 即 3; 当 i=1 时, 输 出 x[1][1] 即 5; 当 i=2 时, 输 出 x[2][0] 即 7 因 此 本 题 答 案 为 C 26. 下 列 程 序 的 输 出 结 果 是 83

84 char s[]="abcdef"; s[3]= '\0'; printf("%s\n",s); 分 析 答 案 为 abc 本 题 考 核 的 知 识 点 是 字 符 串 的 输 出 字 符 串 结 束 标 记 '\0', 当 输 出 一 个 存 放 在 字 符 数 组 中 的 字 符 串 时, 只 需 输 出 到 '\0' 为 止, 而 不 管 其 后 有 什 么 数 据 本 题 给 字 符 串 数 组 s 的 元 素 s[3] 赋 值 为 '\0', 故 只 能 输 出 3 个 字 符 abc 27. 当 执 行 下 面 的 程 序 时, 如 果 输 入 ABC, 则 输 出 的 结 果 是 char ss[10]= "12345"; gets(ss); strcat(ss, "6789"); printf("%s\n",ss); 分 析 答 案 为 ABC6789 字 符 数 组 ss 共 有 10 个 元 素, 初 始 化 为 "12345\0" 执 行 语 句 gets(ss) 后 ss 的 内 容 变 为 "ABC\05\0", 执 行 strcat(ss, "6789") 后 ss 的 内 容 变 为 "ABC6789\0", 因 此, 程 序 的 输 出 结 果 为 ABC 以 下 程 序 段 输 出 的 结 果 是 char st[20]= "hello\0\t\'\\\141"; printf("%d %d \n",strlen(st),sizeof(st)); 分 析 答 案 为 5 20 字 符 数 组 st 有 20 个 元 素, 其 初 始 化 的 内 容 为 "hello\0\t\'\\\141\0", 其 中 '\t' '\'' '\\' 和 '\141' 是 转 义 字 符 strlen(st) 是 求 第 一 个 '\0' 前 的 字 符 个 数,sizeof(st) 是 求 字 符 数 组 st 在 内 存 中 占 据 的 字 节 个 数,strlen(st)=5,sizeof(st)= 以 下 程 序 运 行 后 输 出 的 结 果 是 char ch[]="abc",x[3][4]; int i; for(i=0;i<3;i++) strcpy(x[i],ch); for(i=0;i<3;i++) printf("%s",&x[i][i]); 分 析 答 案 为 abcbcc 语 句 strcpy(x[i],ch) 使 得 x 数 组 的 第 i 行 存 放 "abc", 第 一 个 循 环 就 是 数 组 x 的 每 一 行 都 存 放 了 "abc", 语 句 printf("%s",&x[i][i]) 输 出 从 x[i][i] 开 始 的 字 符 串 因 此, 第 一 次 输 出 "abc", 第 二 次 输 出 "bc", 第 三 次 输 出 "c" 30. 以 下 程 序 段 把 b 字 符 串 连 接 到 a 字 符 串 的 后 面, 请 填 空 int num=0,n=0; while(a[num]!= ) num++; while(b[n])a[num]=b[n]; num++; ; 分 析 答 案 为 '\0' n++ 或 n+=1 程 序 中 第 一 个 while 循 环 语 句 的 功 能 是 计 算 a 字 符 串 的 长 度, 存 放 于 num 中 第 二 个 while 循 环 语 句 的 功 能 是 计 算 b 字 符 串 连 接 到 a 字 符 串 的 后 面,b 的 循 环 变 量 为 n, 所 以 第 一 个 空 格 应 填 '\0', 第 二 个 空 格 应 填 n 设 有 数 组 定 义 :char array[]="china";, 则 数 组 array 所 占 的 空 间 为 个 字 节 分 析 答 案 为 6 用 字 符 串 "China" 初 始 化 字 符 数 组 是, 数 组 中 存 放 的 是 "China\0", 由 84

85 于 定 义 时 没 有 指 定 array 数 组 的 元 素 个 数, 所 以 数 组 的 元 素 个 数 默 认 为 6,array 数 组 占 据 6 个 字 节 的 存 储 单 元 32. 执 行 下 面 的 程 序 段 后, 变 量 k 中 的 值 为 int k=3,s[1]; s[0]=k; k=s[1]*10; 分 析 答 案 为 不 定 值 C 语 言 规 定 只 有 静 态 数 组 和 全 局 数 组 不 用 初 始 化, 且 默 认 值 为 0; 动 态 存 储 类 型 的 数 组 如 果 没 有 进 行 初 始 化, 它 存 放 的 内 容 就 是 随 机 的 数 组 s 是 动 态 数 组 且 没 有 进 行 初 始 化, 因 此 k 的 值 不 确 定 33. 下 面 程 序 输 出 的 结 果 是 int a[3][3]=1,2,3,4,5,6, i, j, s=0; for(i=1;i<3;i++) for(j=0;j<=i;j++) s+=a[i][j]; printf("%d\n",s); 分 析 答 案 为 18 数 组 a 的 初 始 值 分 别 为 a[0][0]=1 a[0][1]=2 a[0][2]=0 a[1][0]=3 a[1][1]=4 a[1][2]=0 a[2][0]=5 a[2][1]=6 a[2][2]=0 二 重 for 循 环 控 制 数 组 元 素 的 累 加 循 环 结 束 后 s 中 累 加 的 数 组 元 素 为 a[1][0] a[1][1] a[2][0] a[2][1] 和 a[2][2] 34. 执 行 下 列 程 序 时 输 入 :123< 空 格 >456< 空 格 >789< 回 车 >, 输 出 结 果 是 char s[100];int c,i; scanf("%c",&c); scanf("%d",&i); scanf("%s",s); printf("%c,%d,%s\n",c,i,s); 分 析 答 案 为 1,23,456 第 一 个 scanf 函 数 读 入 字 符 '1' 到 变 量 c 中 ; 第 二 个 scanf 函 数 遇 到 第 一 个 空 格 符 结 束, 将 1 后 面 的 23 作 为 整 数 读 入 i 中 ; 第 三 个 scanf 函 数 遇 到 第 二 个 空 格 后 将 456 作 为 字 符 串 读 入 数 组 s 中 因 此 输 出 为 1,23, 下 列 程 序 的 运 行 结 果 是 char s[]="a good world";int i,j; for(i=j=0;s[i]!= '\0';i++) if(s[i]!= 'd') s[j++]=s[i]; s[j]= '\0'; printf("%s\n",s); 分 析 答 案 为 a goo worl for 循 环 的 功 能 是 将 字 符 串 中 的 字 符 d 去 掉, 并 将 其 后 面 的 所 有 字 符 向 前 移 动 一 位 变 量 i 依 次 指 示 原 字 符 串 中 字 符 的 位 置, 变 量 j 依 次 指 示 所 形 成 的 新 字 符 串 中 字 符 的 位 置, 原 字 符 串 和 新 字 符 串 占 据 同 一 内 存 空 间 数 组 s 最 后 给 新 字 符 串 添 加 结 束 符 '\0' 36. 当 数 组 名 作 为 函 数 实 参 时, 数 组 元 素 值 会 回 传 吗? 85

86 [ 分 析 ] 用 数 组 名 作 函 数 实 参 时, 是 把 实 参 数 组 的 起 始 地 址 传 递 给 了 形 参 数 组, 这 样 两 个 数 组 共 同 占 用 同 一 段 内 存 空 间, 此 时, 如 果 形 参 数 组 中 各 元 素 的 值 发 生 了 变 化, 会 使 实 参 数 组 元 素 的 值 同 时 发 生 变 化, 感 觉 上 形 参 数 组 元 素 的 值 回 传 给 了 实 参 37. 已 知 如 下 函 数 add 及 float s[5],avg; 语 句 不 正 确 float add(float array[],int n) int i; float sum; sum=0; for (i=0;i<n;i++) sum=sum+array[i]; return(sum); A. printf("%7.2f",add(s,3)); B. printf("%7.2f",add(s,5)); C. printf("%7.2f",add(s[],5)); D. avg=add(s,5)/5; 分 析 答 案 为 C 此 题 考 核 了 数 组 作 为 函 数 实 参 时 的 使 用, 函 数 调 用 时 实 参 中 应 该 是 数 组 的 名 字 38. 有 函 数 f 如 下 : f(char c[],char a) int i,n,cnt=0; n=strlen(c); for (i=0;i<n;i++) if (c[i]==a) cnt++; if (cnt>=3) for (i=0;i<n;i++) if (c[i]==a) c[i]='\0';break; return(cnt); 如 果 定 义 char c[]="this is a string.", 那 么 语 句 printf("there are %d %c in %s.",f(c, i ),'i',c); 的 运 行 结 果 是 A. there are 0 i in this is a string. B. there are 0 i in th. C. there are 3 i in th. D. there are 3 i in this is a string. 分 析 答 案 为 C 注 意 此 题 有 个 陷 阱, 在 调 用 完 函 数 f 后, 字 符 数 组 c 的 值 已 经 发 生 了 变 化, 已 经 变 成 了 th 39. 当 用 多 维 数 组 名 作 函 数 参 数 时, 下 列 说 法 中 正 确 的 是 A. 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 必 须 指 明 每 一 维 的 大 小 B. 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 可 以 省 略 第 一 维 的 大 小 说 明 C. 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 可 以 省 略 所 有 维 数 的 说 明 D. 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 必 须 保 留 第 一 维 的 大 小 说 明 86

87 分 析 答 案 为 B 多 维 数 组 名 作 为 函 数 调 用 的 实 参 和 形 参 时, 在 被 调 用 函 数 中 对 形 参 数 组 定 义 时, 可 以 指 定 每 一 维 的 大 小, 也 可 以 省 略 第 一 位 的 大 小 说 明 但 其 他 维 的 大 小 说 明 不 能 省 略 40. 已 知 一 数 组 b[3][3]=1,23,6,3,7,9,5,2,3, 则 函 数 add(b)= add(int a[3][3]) int m; int i,j; m=0; for (i=0;i<3;i++) for (j=0;j<3;j++) if (i==j) m=a[i][j]+m; return(m); 分 析 答 案 为 11 函 数 add 的 作 用 是 求 矩 阵 对 角 线 的 和 练 一 练 一 单 选 题 1. 若 有 定 义 :int *p[3];, 则 以 下 叙 述 中 正 确 的 是 A. 定 义 了 一 个 基 类 型 为 int 的 指 针 变 量 p, 该 变 量 具 有 三 个 指 针 B. 定 义 了 一 个 指 针 数 组 p, 该 数 组 含 有 三 个 元 素, 每 个 元 素 都 是 基 类 型 为 int 的 指 针 C. 定 义 了 一 个 名 为 *p 的 整 型 数 组, 该 数 组 含 有 三 个 int 类 型 元 素 D. 定 义 了 一 个 可 指 向 一 维 数 组 的 指 针 变 量 p, 所 指 一 维 数 组 应 具 有 三 个 int 类 型 元 素 2. 下 面 能 正 确 进 行 字 符 串 赋 值 操 作 的 语 句 是 A.char s[5]= "ABCDE" B.char s[5]= A, B, C, D, E ; C. char *s;s="abcdef" D.char *s;scanf("%s",s); 3. 设 有 定 义 :int n=0,*p=&n,**q=&p; 则 以 下 选 项 中, 正 确 的 赋 值 语 句 是 A. p=1; B. *q=2; C. q=p; D. *p=5; 4. 若 有 说 明 :int i, j=2,*p=&i;, 则 能 完 成 i=j 赋 值 功 能 的 语 句 是 A. i=*p; B. p*=*&j; C. i=&j; D. i=**p; 5. 有 如 下 程 序 段 int *p, a=10,b=1 p=&a; a=*p+b; a 的 值 为 A. 12 B. 11 C. 10 D. 编 译 出 错 二 填 空 题 1. 计 算 0x5E 0x20 和 0x5E&~(1<<2) 的 值, 结 果 用 16 进 制 表 示 2. 设 float x; 写 出 表 达 式 :x 四 舍 五 入 后 的 整 数 值 3. 设 char *pc[3]; 试 用 puts 写 出 语 句 : 输 出 字 符 串 pc[1] 4. 设 int a[10],s,i; 写 出 语 句 片 段 : 计 算 a 数 组 的 累 加 和 至 变 量 s 三 程 序 调 试 题 ( 下 列 各 程 序 中 存 在 一 些 问 题, 通 过 调 试 发 现 问 题, 并 加 以 修 正, 使 其 实 现 预 期 目 标 (20 分 )) 1 下 列 给 定 的 程 序 中, 函 数 fun() 的 功 能 是 : 用 选 择 法 对 数 组 中 的 n 个 元 素 按 从 大 到 小 的 顺 序 进 行 排 序 请 改 正 程 序 中 的 错 误, 并 上 机 调 试, 使 它 能 得 到 正 确 结 果 87

88 源 程 序 如 下 : #include<stdio.h> #define N 20 void fun(int a[],int n) int i,j,t,p; for(j=0;j<n-1;j++); p=j; for(i=j;i<n;i++) if(a[i]<a[p]) p=i; t=a[p]; a[p]=a[j]; a[p]=t; int a[n]=11,32,-5,2,14,i,m=5; printf(" 排 序 前 的 数 据 :"); for(i=0;i<m;i++) printf("%d ",a[i]); printf("\n"); fun(a,m); printf(" 排 序 后 的 顺 序 :"); for(i=0;i<m;i++) printf("%d ",a[i]); printf("\n"); 2 下 列 给 定 程 序 中, 函 数 fun 的 功 能 是 : 逐 个 比 较 a b 两 个 字 符 串 对 应 位 置 中 的 字 符, 把 ASCII 值 大 或 等 于 的 字 符 存 放 到 c 数 组 中, 形 成 一 个 新 的 字 符 串 例 如, 若 a 中 的 字 符 串 为 abcdefgh,b 中 的 字 符 串 为 :ABcd, 则 c 中 的 字 符 串 为 :abcdefgh 请 改 正 程 序 中 的 错 误, 使 程 序 能 得 出 正 确 的 结 果 #include <stdio.h> #include <string.h> void fun(char p[],char q[],char c[]); int k=1,i=0,j=0; while(p[i]!='\0' q[j]!='\0') if (p[i]<=q[j]) c[k]=p[i]; else 88

89 c[k]=q[j]; if (p[i]) i++; if (q[j]) j++; k++; static char a[10]="abcdefgh",b[10]="abcd",c[80]; fun(a,b,c); printf("the string a:"); puts(a); printf("the string b:"); puts (b); printf("the result:"); puts(c); 3 下 列 给 定 程 序 中, 函 数 fun 的 功 能 是 : 在 字 符 串 str 中 找 出 ASCII 码 值 最 大 的 字 符, 将 其 放 在 第 一 个 位 置 上 ; 并 将 该 字 符 前 的 原 字 符 向 后 顺 序 移 动 例 如, 调 用 fun 函 数 之 前 给 字 符 串 输 入 :ABCDeFGH, 调 用 后 字 符 串 中 的 内 容 为 eabcdfgh 请 改 正 程 序 中 的 错 误, 使 程 序 能 得 出 正 确 的 结 果 #include <stdio.h> #include <string.h> fun(char p[]) char max,*q;int i=0; max=p[i];q=p; while(p[i]='\0') if(max>p[i]) max=p[i]; q=p+i; i++; while(q>p) *q=*(q-1); q++; p[0]=max; char str[80]; printf("enter a string:");gets(str); printf("\nthe original string: ");puts(str); fun(str); printf("\nthe string agter moving: ");puts (str); 89

90 四 程 序 填 空 题 ( 请 填 写 适 当 的 符 号, 使 程 序 实 现 其 功 能 ) 1. 以 下 程 序 中 函 数 reverse 的 功 能 是 将 a 所 指 数 组 中 的 内 容 进 行 逆 置 请 填 空 程 序 4.1 #include <stdio.h> void reverse(int a[ ],int n) int i,t; for(i=0;i< ; i++) t=a[i]; a[i]=a[n-1-i];a[n-1-i]=t; int b[10]=10,12,3,8,54,36,7,22,19,100; int i,s=0; reverse ; for(i=0;i<10;i++) printf("%5d", ); 2. 以 下 程 序 的 功 能 : 第 一 个 数 是 1, 从 第 二 个 数 起 每 个 数 都 是 它 的 前 一 项 加 5, 求 第 n 个 数 是 多 少?(n 从 键 盘 输 入 ) 程 序 4.2 #include <stdio.h> long add(int n) long m; if ( ) m=1; else m= ; return( ); long m; int n; printf("input n:\n"); scanf("%d",&n); m=add(n); printf("%ld\n",m); 3. 以 下 程 序 的 功 能 是 把 字 符 串 str 中 的 数 字 字 符 转 换 成 数 字 并 存 放 到 整 型 数 组 bb 中, 函 数 返 回 数 组 bb 的 长 度 例 如 :str= Bcd123e456hui890, 结 果 为 : 请 填 空 程 序 4.3 #include<stdio.h> #define N 80 int bb[n]; int fun(char s[],int bb[],int num) int i,n=0; for(i=0;i<num;i++) 90

91 if( ) bb[n]= ; n++; return ; char str[n]; int num=0,n,i; printf("enter a string:\n"); gets(str); while(str[num]) num++; n=fun(str,bb,num); printf("\nbb= "); for(i=0;i<n;i++) printf("%d",bb[i]); 4. 以 下 程 序 的 功 能 是 : 从 数 组 xx 中 找 出 个 位 和 十 位 的 数 字 之 和 大 于 5 的 所 有 无 符 号 整 数, 结 果 保 存 在 数 组 yy 中, 其 个 数 由 函 数 fun() 返 回 请 填 空 例 如 : 当 xx[8]=123,11,25,222,42,333,14,5451 时, bb[4]=25,42,333,5451 程 序 4.4 #include <stdio.h> #define N 1000 int fun(int xx[],int bb[],int num) int i, n=0; int g, s; for(i=0;i<num;i++) g= ; s=xx[i]/10%10; if((g+s)>5) ; return ; int xx[n]; int yy[n]; int num=0,n=0,i=0; printf("input number (0 is end) :\n"); do scanf("%u",&xx[num]); while(xx[num++]!=0); n=fun(xx,yy,num); printf("\nyy="); 91

92 for(i=0;i<n;i++) printf("%u ",yy[i]); 五 编 程 1. 编 写 一 个 函 数 fun, 累 计 当 前 人 数 和 总 分, 并 返 回 当 前 为 止 的 平 均 分 调 用 该 函 数 输 出 10 个 学 生 的 平 均 分 统 计 结 果 2. 编 写 一 个 函 数 fun, 计 算 (n 个 2,n 由 键 盘 输 入 ) 第 4 章 结 构 体 和 链 表 结 构 体 类 型 和 链 表 是 用 户 构 造 而 成 的, 它 们 的 功 能 更 加 强 大 图 4-1 结 构 体 与 链 表 的 知 识 网 络 图 92

93 4.1 结 构 体 结 构 体 类 型 的 定 义 和 变 量 的 声 明 1. 结 构 体 类 型 的 定 义 C 语 言 对 结 构 体 类 型 的 定 义 形 式 如 下 : struct 结 构 体 名 成 员 项 表 列 ; ; 注 意 : (1) 关 键 字 struct 是 用 来 声 明 结 构 体 类 型 的 关 键 字, 不 能 省 略 结 构 体 名 满 足 标 识 符 定 义 的 规 则, struct+ 结 构 体 名 才 是 完 整 的 结 构 体 类 型 名, 才 可 以 用 来 声 明 变 量 每 一 个 数 据 项 又 称 为 结 构 体 的 一 个 成 员 或 域 (2) 成 员 表 列 不 可 为 空, 至 少 要 有 一 个 成 员 成 员 要 声 明 类 型, 其 类 型 可 以 是 任 意 类 型, 可 以 是 简 单 类 型 ( 如 int float char), 也 可 以 是 构 造 类 型 ( 如 数 组 ) (3) 大 括 号 不 表 示 复 合 语 句, 其 后 要 有 分 号, 表 示 结 构 体 类 型 定 义 结 束 (4) 同 一 结 构 体 的 成 员 不 能 重 名 ; 而 不 同 结 构 体 的 成 员 可 以 重 名, 结 构 体 成 员 和 其 他 变 量 可 以 重 名, 结 构 体 类 型 与 其 成 员 或 其 他 变 量 可 以 重 名 (5) 一 般 把 结 构 体 类 型 声 明 放 到 代 码 的 最 前 面, 这 样 其 使 用 范 围 可 以 整 个 程 序 文 件 ; 也 可 以 放 在 头 文 件 里, 只 有 把 头 文 件 包 含 进 行 即 可 使 用 该 类 型 若 在 函 数 内 部 声 明 结 构 体 类 型, 则 该 函 数 之 外 无 法 引 用 此 结 构 体 类 型 2. 结 构 体 变 量 的 声 明 有 了 结 构 体 类 型, 就 可 以 声 明 结 构 体 类 型 的 变 量 了 声 明 变 量 有 3 种 方 式 (1) 先 定 义 类 型, 后 声 明 变 量 用 已 经 定 义 好 的 结 构 体 类 型 来 声 明 变 量 struct 结 构 体 名 变 量 名 ; 例 如 : struct stud stu1,stu2; (2) 定 义 类 型 同 时 声 明 变 量 struct stud int num; /* 学 号 */ char name[20]; /* 姓 名 */ float score[3]; /*3 门 课 程 分 数 */ s1,st1; 则 stu1,stu2 是 相 同 类 型 的 结 构 体 变 量 (3) 直 接 声 明 变 量 struct int num; /* 学 号 */ char name[20]; /* 姓 名 */ 93

94 float score[3]; /*3 门 课 程 分 数 */ s1,st1 ; 注 意 3 种 形 式 的 区 别 第 1 种 和 第 2 形 式 可 以 随 时 使 用 结 构 体 类 型 来 定 义 若 干 个 变 量 这 里,struct student 就 如 以 前 用 过 的 int 和 char 等 类 型 声 明 符 不 过 int 和 char 是 系 统 给 出 的, 而 struct student 是 程 序 员 自 己 定 制 的 而 第 3 种 形 式 没 有 类 型 名, 以 后 就 不 能 声 明 相 同 类 型 的 变 量 ( 只 有 类 型 名 相 同 才 是 相 同 类 型 ), 因 此 第 3 种 形 式 一 般 不 用 通 常, 把 struct + 结 构 体 类 型 名 定 义 为 一 个 符 号 常 量, 例 如,struct student 可 以 定 义 为 : #define STUDENT struct student 这 样, 以 后 引 用 时 就 方 便 多 了, 并 且 简 单 明 了 注 意 : 结 构 体 类 型 可 以 嵌 套 定 义 结 构 体 变 量 的 存 储 与 成 员 的 引 用 1. 结 构 体 变 量 的 存 储 结 构 体 变 量 的 存 储 长 度 : 各 个 成 员 所 占 的 存 储 单 元 的 总 和 设 有 如 下 声 明 : struct stud s1; 则 变 量 的 存 储 形 式 如 图 4-2 所 示 图 4-2 变 量 s1 的 存 储 形 式 可 见, 每 个 成 员 有 各 自 相 对 独 立 的 存 储 单 元, 按 定 义 时 顺 序 存 储 根 据 其 不 同 的 类 型,num 占 2 个 字 节,name 占 20 个 字 节, score 是 float 类 型 的 数 组, 有 3 个 元 素, 占 12 个 字 节, 整 个 变 量 s1 占 34 个 字 节 每 个 成 员 的 地 址 也 不 同, 结 构 体 变 量 的 地 址 值 与 第 一 个 成 员 的 地 址 值 相 同, 但 意 义 不 同, 一 个 是 整 个 变 量 的 地 址, 一 个 是 成 员 的 地 址 注 意 类 型 名 与 变 量 名 的 区 别 : 类 型 名 的 定 义 只 规 定 该 类 型 应 分 配 的 存 储 空 间 的 大 小, 但 不 分 配 相 应 的 内 存 单 元 ; 声 明 结 构 体 变 量 时 才 给 变 量 分 配 内 存 单 元 2. 结 构 体 变 量 成 员 的 引 用 与 成 员 运 算 符 若 已 定 义 了 一 个 结 构 体 变 量 和 基 类 型 为 同 一 结 构 体 类 型 的 指 针 变 量, 并 使 该 指 针 指 向 同 类 型 的 变 量, 则 有 3 种 形 式 来 引 用 结 构 体 变 量 中 的 成 员 结 构 体 变 量 名 也 可 以 是 已 经 定 义 的 结 构 体 数 组 的 数 组 元 素 :3 种 形 式 如 下 : 结 构 体 变 量 名. 成 员 名 指 针 变 量 名 > 成 员 名 (* 指 针 变 量 名 ). 成 员 名 对 内 嵌 结 构 体 变 量 成 员 的 引 用, 必 须 逐 层 使 用 成 员 名 定 位, 对 于 多 层 嵌 套 的 结 构 体, 也 是 按 照 从 最 外 层 到 最 内 层 的 顺 序 逐 层 引 用, 每 层 之 间 用 点 号 隔 开 3. 结 构 体 变 量 的 初 始 化 94

95 与 简 单 变 量 相 同, 结 构 体 变 量 也 可 以 在 声 明 的 同 时 进 行 初 始 化 例 如 : struct stud stu1=6002,"li Hao",85,78,90; 说 明 : (1) 不 完 全 初 始 化, 则 没 有 初 始 化 的 成 员 自 动 初 始 化 为 0 或 '\0' 全 部 成 员 无 初 始 化, 则 所 有 成 员 均 为 不 确 定 量, 不 会 自 动 初 始 化 为 0 或 '\0' (2) 下 面 的 初 始 化 方 式 是 错 误 的, 初 始 化 是 对 变 量 进 行 初 始 化, 不 是 对 一 个 个 的 成 员 进 行 初 始 化 struct stud int num=6002; char name[20]= "Li Hao"; float score[3]=85,78,90; stu1; (3) 若 有 嵌 套 的 结 构 体 类 型 变 量, 则 按 定 义 时 的 成 员 顺 序 逐 一 初 始 化 struct stud1 st1==6002, "Li Hao",11,6,2006,85,78,90; 则 st1.num=6002,st1.name="li Hao",st1.age.month=11,st1.age.day=6,st1.age.year= 2006, st1.score[0]=85,st1.score[1]=78,st1.score[2]= 结 构 体 数 组 1. 结 构 体 数 组 的 声 明 和 存 储 先 定 义 结 构 体 类 型, 后 声 明 结 构 体 数 组 和 变 量 声 明 一 样, 结 构 体 数 组 的 声 明 有 3 种 形 式 struct studt int num; char name[20]; float score; ; struct stud stu[3]; 说 明 : 结 构 体 数 组 有 3 个 元 素, 每 个 元 素 有 3 个 成 员, 每 个 元 素 占 26 个 字 节, 数 组 占 内 存 78 个 字 节 数 组 元 素 按 下 标 的 顺 序 存 储, 每 个 元 素 的 所 有 成 员 按 定 义 的 顺 序 存 储, 如 图 4-3 所 示 95

96 图 4-3 结 构 体 数 组 的 存 储 2. 结 构 体 数 组 元 素 的 引 用 与 变 量 一 样, 只 能 用 成 员 运 算 符 引 用 数 组 元 素 的 某 个 成 员 对 结 构 体 数 组 元 素 成 员 的 引 用 形 式 为 : < 结 构 体 数 组 名 [ 下 标 ]>.< 结 构 成 员 > 例 4.1 输 入 N 名 学 生 的 学 籍 信 息, 并 按 一 定 格 式 输 出 #include <stdio.h> #define N 3 struct student int num; char name[20]; float score[3]; ; void struct student stu[n]; int i,j; printf("input student information:\n"); for(i=0;i<n;i++) printf("num:"); scanf("%d",&stu[i].num); flushall();/*flushall() 函 数 清 空 缓 冲 区 */ printf("name:"); scanf("%s",stu[i].name);flushall(); for(j=0;j<3;j++) /* 输 入 门 课 分 数 */ printf("score %d:",j+1); /* 输 入 第 j+1 门 课 分 数,j 从 开 始 */ scanf("%f",&stu[i].score[j]);flushall(); printf("num\tname\tscore[0]\tscore[1]\tscore[2]\n"); for(i=0;i<n;i++) printf("%d\t%s\t",stu[i].num,stu[i].name); printf("%f\t",stu[i].score[0]); printf("%f\t", stu[i].score[1]); printf("%f\n",stu[i].score[2]); 3. 结 构 体 数 组 的 初 始 化 结 构 体 数 组 和 结 构 体 变 量 一 样, 可 在 3 个 位 置 进 行 初 始 化 元 素 之 间 用 逗 号 分 隔, 可 以 用 大 括 号 括 起 来, 各 成 员 按 定 义 的 顺 序 初 始 化, 成 员 为 数 组 的 也 可 以 用 大 括 号 括 起 来 如 下 面 的 初 始 化 : static struct studt int num; 96

97 char name[20]; float score[3]; stu[3]= 6031, "li", 78,85,68, 6032, "zhang ",85,98,81, 6033, "he ", 74,76,85; 分 别 对 数 组 的 各 成 员 进 行 初 始 化 这 样, 数 组 各 元 素 如 下 : stu[0].num=6031,stu[0].name= li,stu[0].score[0]=78,stu[0].score[1]=85,stu[0].score[2]=68; stu[1].num=6032,stu[1].name= zhan,stu[1].score[0]=85,stu[2].score[1]=98,stu[1].score[2]= 81; stu[2].num=6032,stu[2].name= he,stu[3].score[0]=74,stu[2].score[1]=76,stu[2].score[2]= 函 数 之 间 结 构 体 变 量 的 数 据 传 递 在 C 语 言 的 较 老 版 本 的 标 准 中, 在 调 用 函 数 时 不 允 许 将 结 构 体 变 量 作 为 实 参 进 行 整 体 传 送, 而 只 能 逐 个 传 递 结 构 体 变 量 中 的 成 员 但 新 的 ANSI C 标 准 支 持 将 结 构 体 变 量 作 为 实 参 进 行 整 体 传 送 传 递 的 具 体 形 式 为 : (1) 函 数 传 递 结 构 体 变 量 的 成 员 每 个 成 员 可 以 是 是 简 单 变 量 数 组 或 指 针 变 量 等, 作 为 成 员 变 量, 它 们 可 以 参 与 所 属 类 型 允 许 的 任 何 操 作 同 样 地, 在 参 数 传 递 中 结 构 体 变 量 的 成 员 也 同 一 般 变 量 一 样 (2) 向 函 数 传 递 结 构 体 变 量 新 的 ANSI C 标 准 允 许 包 结 构 体 变 量 作 为 一 个 整 体 传 送 给 相 应 的 形 参 此 时 参 数 传 递 采 用 的 是 值 传 递 方 式, 也 即 这 时 传 递 的 是 实 参 结 构 体 变 量 的 值, 系 统 将 为 结 构 体 类 型 的 形 参 开 辟 相 应 的 存 储 单 元, 并 将 实 参 中 个 成 员 的 值 赋 给 对 应 的 形 参 结 构 体 变 量 的 成 员 (3) 传 递 结 构 体 的 地 址 C 语 言 允 许 将 结 构 体 变 量 的 地 址 作 为 实 参 传 递 此 时, 参 数 传 递 采 用 的 就 是 地 址 传 递 方 式, 这 时, 对 应 的 形 参 应 该 是 一 个 基 类 型 相 同 的 结 构 体 类 型 的 指 针 系 统 只 需 为 形 参 指 针 开 辟 一 个 存 储 单 元 存 放 实 参 结 构 体 变 量 的 地 址 值, 而 不 必 另 行 建 立 一 个 结 构 体 变 量 这 样 可 以 减 少 系 统 操 作 所 需 的 时 间, 提 高 程 序 的 执 行 效 率 ; 同 时, 还 可 以 通 过 函 数 调 用, 有 效 地 修 改 结 构 体 中 成 员 的 值 (4) 函 数 的 返 回 值 是 结 构 体 类 型 (5) 函 数 的 返 回 值 可 以 是 指 向 结 构 体 变 量 的 指 针 类 型 指 向 结 构 变 量 的 指 针 一 个 指 针 变 量 当 用 来 指 向 一 个 结 构 变 量 时, 称 之 为 结 构 指 针 变 量 结 构 指 针 变 量 中 的 值 是 所 指 向 的 结 构 变 量 的 首 地 址 通 过 结 构 指 针 即 可 访 问 该 结 构 变 量, 这 与 数 组 指 针 和 函 数 指 针 的 情 况 是 相 同 的 结 构 指 针 变 量 说 明 的 一 般 形 式 为 : struct 结 构 名 * 结 构 指 针 变 量 名 结 构 名 和 结 构 变 量 是 两 个 不 同 的 概 念, 不 能 混 淆 结 构 名 只 能 表 示 一 个 结 构 形 式, 编 译 系 统 并 不 对 它 分 配 内 存 空 间 只 有 当 某 变 量 被 说 明 为 这 种 类 型 的 结 构 时, 才 对 该 变 量 分 配 存 储 空 间 因 此 上 面 &stu 这 种 写 法 是 错 误 的, 不 可 能 去 取 一 个 结 构 名 的 首 地 址 有 了 结 构 指 针 变 量, 就 能 更 方 便 地 访 问 结 构 变 量 的 各 个 成 员 其 访 问 的 一 般 形 式 为 : 97

98 或 为 : (* 结 构 指 针 变 量 ). 成 员 名 结 构 指 针 变 量 -> 成 员 名 4.2 共 用 体 1. 共 用 体 类 型 的 定 义 C 语 言 对 结 构 体 类 型 的 定 义 形 式 如 下 : union 共 用 体 名 成 员 项 表 列 ; ; 这 里,union 是 关 键 字, 表 明 定 义 的 是 共 用 体 类 型 共 用 体 名 满 足 标 识 符 定 义 的 规 则, union+ 共 用 体 名 才 是 完 整 的 共 用 体 类 型 名 每 一 个 数 据 项 又 称 为 共 用 体 的 一 个 成 员 或 域 2. 共 用 体 变 量 的 声 明 共 用 体 变 量 的 声 明 与 结 构 体 相 似, 分 别 有 3 种 声 明 形 式 (1) 先 定 义 类 型, 后 声 明 变 量 (2) 声 明 同 时 定 义 (3) 直 接 声 明 3. 共 用 体 变 量 的 存 储 和 成 员 的 引 用 共 用 体 数 据 类 型 与 结 构 体 在 形 式 上 非 常 相 似, 但 其 表 示 的 含 义 及 存 储 方 式 是 完 全 不 同 的 让 先 看 一 个 小 例 子 结 构 体 变 量 在 内 存 中 的 长 度 是 其 各 个 成 员 占 内 存 的 长 度 之 和, 而 共 用 体 占 内 存 的 长 度 是 其 占 内 存 空 间 最 长 的 成 员 的 长 度 注 : C 语 言 对 共 用 体 变 量 成 员 的 引 用 形 式 如 下 : < 类 型 变 量 名 >.< 成 员 名 > 一 次 只 能 引 用 一 个 共 用 体 成 员 不 能 给 共 用 体 变 量 初 始 化, 可 以 定 义 共 用 体 数 组 不 能 给 共 用 体 变 量 名 赋 值, 共 用 体 变 量 也 不 能 作 为 函 数 的 参 数 及 函 数 的 返 回 值 共 用 体 类 型 和 结 构 体 类 型 可 以 相 互 嵌 套, 共 用 体 中 成 员 可 以 为 数 组, 甚 至 还 可 以 是 共 用 体 数 组 4.3 链 表 概 念 采 用 动 态 分 配 的 办 法 为 一 个 结 构 分 配 内 存 空 间, 每 一 次 分 配 一 块 空 间 可 用 来 存 放 一 个 对 象 的 数 据, 称 之 为 一 个 结 点 结 点 之 间 的 联 系 可 以 用 指 针 实 现 即 在 结 点 结 构 中 定 义 一 个 成 员 项 用 来 存 放 下 一 结 点 的 首 地 址, 这 个 用 于 存 放 地 址 的 成 员, 常 把 它 称 为 指 针 域 可 在 第 一 个 结 点 的 指 针 域 内 存 入 第 二 个 结 点 的 首 地 址, 在 第 二 个 结 点 的 指 针 域 内 又 存 98

99 放 第 三 个 结 点 的 首 地 址, 如 此 串 连 下 去 直 到 最 后 一 个 结 点 最 后 一 个 结 点 因 无 后 续 结 点 连 接, 其 指 针 域 可 赋 为 0 这 样 一 种 连 接 方 式, 在 数 据 结 构 中 称 为 链 表 图 4-4 为 最 一 简 单 链 表 的 示 意 图 图 4-4 简 单 链 表 的 示 意 图 图 中, 第 0 个 结 点 称 为 头 结 点, 它 存 放 有 第 一 个 结 点 的 首 地 址, 它 没 有 数 据, 只 是 一 个 指 针 变 量 以 下 的 每 个 结 点 都 分 为 两 个 域, 一 个 是 数 据 域, 存 放 各 种 实 际 的 数 据, 如 学 号 num, 姓 名 name, 性 别 sex 和 成 绩 score 等 另 一 个 域 为 指 针 域, 存 放 下 一 结 点 的 首 地 址 链 表 中 的 每 一 个 结 点 都 是 同 一 种 结 构 类 型 链 表 的 基 础 操 作 作 为 数 据 组 织 的 一 种 形 式, 链 表 的 基 本 操 作 也 常 包 括 以 下 功 能 : 链 表 的 建 立 链 表 结 点 的 插 入 链 表 结 点 的 删 除 链 表 的 遍 历 查 找 元 素 连 接 两 个 链 表 1. 链 表 中 插 入 的 过 程 的 关 键 就 是 指 针 域 指 向 的 改 变 如 图 4-5 所 示 : 图 4-5 结 点 插 入 过 程 p 指 向 的 是 第 i 个 元 素 的 前 一 个 元 素,S 表 示 的 是 即 将 要 插 入 的 新 元 素 首 先 通 过 while 99

100 循 环 找 到 p 的 位 置, 然 后 通 过 s->next=p->next; p->next=s; 来 改 变 结 点 之 间 的 连 接, 从 而 实 现 新 结 点 的 插 入 2. 删 除 一 个 元 素 这 里 有 两 个 辅 助 指 针, 一 个 是 pre, 指 向 被 删 除 的 结 点 的 前 驱 结 点 ; 一 个 是 p, 指 向 被 删 除 结 点 在 单 链 表 中 删 除 一 个 元 素 非 常 简 单, 就 是 将 需 要 删 除 的 元 素 的 前 驱 元 素 pre 的 指 针 域 指 向 被 删 除 元 素 的 后 继 元 素 的 地 址 p->next 如 图 4-6 所 示 : 我 们 要 删 除 结 点 d, 只 需 要 执 行 代 码 :pre->next=p->next; 就 可 实 现 结 点 的 删 除 图 4-6 删 除 结 点 示 意 图 一 般 而 言 删 除 结 点, 都 是 找 到 结 点 后 删 除 有 以 下 几 种 情 况 要 考 虑 : 链 表 是 空 链 表, 直 接 返 回 ; 非 空, 但 未 找 到, 输 出 未 找 到 信 息 ; 非 空, 并 找 到, 是 第 一 个 结 点, 修 改 头 指 针 head=head->nex; 非 空, 并 找 到, 是 中 间 结 点 或 最 后 结 点, 将 需 要 删 除 的 元 素 的 前 驱 元 素 pre 的 指 针 域 指 向 被 删 除 元 素 的 后 继 元 素 的 地 址 p->next 3. 堆 栈 链 堆 栈 是 一 个 标 准 的 常 用 数 据 结 构 之 一, 它 只 允 许 通 过 一 个 受 限 的 元 素 ( 栈 顶 ) 进 行 数 据 的 插 入 和 删 除, 也 就 是 节 点 或 对 象 只 能 被 加 到 列 表 的 顶 部, 和 从 这 个 列 表 的 底 端 删 除 数 据 它 的 规 则 是 先 进 后 出 (FILO), 第 一 个 加 入 的 数 据, 将 最 后 一 个 被 删 除 4. 队 列 链 表 队 列 也 是 一 个 特 殊 的 链 表 结 构, 和 栈 的 最 大 区 别 在 于 其 具 有 队 头 和 队 尾, 插 入 发 生 在 队 列 的 尾 部, 而 删 除 发 生 在 队 列 的 头 部 它 的 规 则 是 先 进 先 出 (FIFO), 就 象 我 们 去 理 发 店 排 队 理 发 一 样, 当 然 是 先 到 的 先 被 服 务 了 在 系 统 的 资 源 调 度 中 常 用 到 队 列 分 析 4.4 典 型 案 例 分 析 1. 结 构 体 与 共 用 体 变 量 在 计 算 机 中 占 用 多 少 内 存? 分 析 结 构 体 变 量 所 占 的 内 存 长 度 等 于 所 有 各 成 员 的 长 度 之 和, 每 个 成 员 分 别 占 有 自 己 的 内 存 单 元 ; 共 用 体 变 量 所 占 的 内 存 长 度 等 于 最 长 的 成 员 的 长 度 100

101 2. 结 构 体 和 共 用 体 有 几 种 不 同 的 引 用 方 法? 分 析 结 构 体 和 共 用 体 一 样, 有 两 种 引 用 办 法, 一 种 是 采 用 成 员 ( 分 量 ) 运 算 符. ; 还 有 一 种 是 采 用 指 针 的 办 法 下 面 以 结 构 体 为 例 说 明 这 两 种 不 同 的 引 用 方 法 struct stu int num; char name[10]; int age; zhangsan, *lisi; 要 访 问 学 生 zhangsan 年 龄 的 办 法 有 两 种 :zhangsan.age 或 者 (&zhangsan)->age; 要 访 问 学 生 lisi 年 龄 的 办 法 也 有 两 种 :(*lisi).age 或 者 lisi->age 3. 结 构 体 类 型 与 结 构 体 变 量 的 区 别? 分 析 例 如 : struct student long num; char name[20]; int score; ; student.num= ; strcpy(student.name, zhangsan ); student.score=65; 这 是 错 误 的,student 是 类 型 名, 不 是 变 量, 它 不 占 用 存 储 单 元 上 面 程 序 段 应 先 定 义 student 类 型 变 量, 再 对 变 量 中 的 成 员 赋 值 struct student st1; st1.num= ; strcpy(st1.name, zhangsan ); st1.score=65; 4. 成 员 运 算 符 和 指 向 运 算 符 的 区 别? 分 析 访 问 结 构 体 成 员 使 用 两 个 C 运 算 符 : 成 员 运 算 符 和 指 向 运 算 符 如 果 obj 是 一 个 变 量 的 名 称, 那 么 使 用 成 员 运 算 符 访 问 其 内 容 如 果 p 是 一 个 指 向 结 构 体 变 量 的 指 针, 则 使 用 指 向 运 算 符 5. 怎 样 理 解 结 构 体 和 数 组? 分 析 结 构 体 是 一 个 可 以 包 含 不 同 数 据 类 型 的 一 个 结 构, 它 是 一 种 可 以 自 己 定 义 的 数 据 类 型, 它 的 特 点 和 数 组 主 要 有 两 点 不 同, 首 先 结 构 体 可 以 在 一 个 结 构 中 声 明 不 同 的 数 据 类 型, 第 二 相 同 结 构 的 结 构 体 变 量 是 可 以 相 互 赋 值 的, 而 数 组 是 做 不 到 的, 因 为 数 组 是 单 一 数 据 类 型 的 数 据 集 合, 它 本 身 不 是 数 据 类 型 ( 而 结 构 体 是 ), 数 组 名 称 是 常 量 指 针, 所 以 不 可 以 做 为 左 值 进 行 运 算, 所 以 数 组 之 间 就 不 能 通 过 数 组 名 称 相 互 复 制 了, 即 使 数 据 类 型 和 数 组 大 小 完 全 相 同 6. 怎 样 定 义 和 引 用 结 构 体 数 组? 分 析 单 个 结 构 体 类 型 变 量 在 解 决 实 际 问 题 时 作 用 不 大, 一 般 是 以 结 构 体 类 型 数 组 的 形 式 出 现 结 构 体 类 型 数 组 的 定 义 形 式 为 : struct stu / * 定 义 学 生 结 构 体 类 型 * / 101

102 char name[20]; / * 学 生 姓 名 * / char gender; / * 性 别 * / long num; / * 学 号 * / float score[3]; / * 三 科 考 试 成 绩 * / ; struct stu stud[20]; /* 定 义 结 构 体 类 型 数 组 stud,*/ / * 该 数 组 有 2 0 个 结 构 体 类 型 元 素 * / 其 数 组 元 素 各 成 员 的 引 用 形 式 为 : stud[i].name stud[i].sex stud[i].score[j]; 其 中 i:0~19,j:0~2 7. 以 下 程 序 运 行 的 输 出 结 果 是 union r; char i[2]; int m; r.i[0]=2;r.i[1]=0; printf("%d\n",r.m); A. 2 B. 1 C. 0 D. 不 确 定 分 析 本 题 涉 及 共 用 体 的 概 念 字 符 数 组 i[2] 与 整 型 变 量 m 使 用 同 一 内 存 单 元 m 占 用 2 个 字 节, 高 字 节 对 应 i[1], 低 字 节 对 应 i[0], 因 此, 本 题 的 正 确 答 案 为 :A 8. 设 有 以 下 结 构 类 型 说 明 和 变 量 定 义, 则 变 量 a 在 内 存 所 占 的 字 节 数 是 struct st char ch[6]; Int s[4]; double ave; a; 分 析 C 语 言 规 定, 结 构 体 变 量 分 配 的 空 间 大 小 为 所 有 成 员 的 存 储 空 间 的 综 合, 因 此, 变 量 a 在 内 存 所 占 字 节 数 是 :6+4*2+8=22 9. 下 列 关 于 结 构 体 的 说 法 错 误 的 是 A. 结 构 体 是 由 用 户 自 定 义 的 一 种 结 构 类 型 ; B. 结 构 体 中 可 设 定 若 干 个 不 同 数 据 类 型 的 成 员 ; C. 结 构 体 中 成 员 的 数 据 类 型 可 以 是 另 一 个 已 定 义 的 结 构 ; D. 在 定 义 结 构 时, 可 以 为 成 员 设 置 默 认 值 分 析 结 构 体 是 一 种 构 造 数 据 类 型, 由 不 同 数 据 类 型 的 数 据 域 组 成, 因 此, 本 题 的 正 确 答 案 为 :D 10. 以 下 程 序 的 输 出 结 果 是 A B C D. 输 出 不 定 值 #include "alloc.h" fun(float *p1,float *p2, float *s) s = (float *) calloc ( 1, sizeof(float)) ; *s = *p1 + *(p2++) ; 102

103 main ( ) float a[2] = 1,1, 2.2, b[2] = 10.0, 20.0, *w ; fun (a, b, w ) ; printf ("%5.2f\n", *w) ; 分 析 C 语 言 规 定, 实 参 与 形 参 之 间 只 能 进 行 按 值 传 递, 对 应 的 实 参 和 形 参 分 别 占 用 不 同 的 存 储 单 元 ; 因 此, 形 参 的 任 何 改 变, 不 影 响 主 调 函 数 实 参 的 值 当 被 调 用 函 数 运 行 结 束 时, 形 参 及 函 数 内 的 变 量 全 部 消 失 ( 释 放 ) 因 此, 当 调 用 fun 函 数 时, 数 组 a b 的 首 地 址 分 别 传 递 给 p1 和 p2, 因 此 p1 和 p2 分 别 指 向 a[0] 和 b[0] 同 样, 被 调 函 数 的 形 参 s 也 接 受 主 调 函 数 的 实 际 参 数 w 的 值, 但 w 中 无 确 定 的 地 址 值, 即, 无 具 体 的 指 向, 因 此 形 参 s 也 无 确 定 的 值 在 fun 函 数 内, 通 过 动 态 分 配, 是 s 指 向 了 一 个 动 态 分 配 的 存 储 空 间, 并 通 过 表 达 式 给 此 存 储 单 元 赋 了 值 (11.1); 但 这 一 切 仅 仅 是 使 得 fun() 函 数 内 形 参 s 有 了 具 体 的 地 址 值, 而 未 影 响 到 主 调 函 数 中 的 实 参 w, 这 个 动 态 分 配 的 空 间 的 地 址 也 没 有 以 任 何 形 式 返 回 给 主 调 函 数, 因 此, 当 被 调 函 数 结 束 时, 形 参 s 消 失, 主 函 数 的 实 参 w 仍 然 没 有 明 确 指 向 哪 一 个 空 间, 也 未 指 向 动 态 分 配 的 空 间, 因 此,*w 的 值 不 定 根 据 以 上 分 析, 本 题 的 正 确 答 案 为 D 11. 设 有 以 下 说 明 语 句 typedef struct int n; PER; char ch[8] ; 则 下 面 叙 述 中 正 确 的 是 A.PER 是 结 构 体 变 量 名 B.PER 是 结 构 体 类 型 名 C.typedef struct 是 结 构 体 类 型 D.struct 是 结 构 体 类 型 名 分 析 本 题 中,typedef 声 明 新 的 类 型 名 PER 来 代 替 已 有 的 类 型 名,PER 代 表 上 面 指 定 的 一 个 结 构 体 类 型 因 此 本 题 的 正 确 答 案 为 B 12. 若 有 以 下 说 明 和 定 义 typedef int *INTEGGER ; INTEGER p, *q ; 以 下 叙 述 正 确 的 是 A. p 是 int 型 变 量 B. p 是 基 类 型 为 int 的 指 针 变 量 C. q 是 基 类 型 为 int 的 指 针 变 量 D. 程 序 中 可 用 INTEGER 代 替 int 类 型 名 分 析 语 句 typedef int * INTEGER ; 定 义 了 一 个 新 类 型 名 INTEGER, 因 此 语 句 INTEGER p, *q ; 就 相 当 于 int *p, * * q; 因 此 本 题 的 正 确 答 案 为 B 13. 以 下 程 序 的 运 行 结 果 是 # include <stdio.h> main ( ) 103

104 struct date int year, month, day ; today ; printf ( % d\n, sizeof (struct date) ) ; A.6 B.8 C.10 D.12 分 析 在 解 答 本 题 时 应 该 考 虑 两 个 问 题 : 结 构 体 变 量 的 长 度 及 sizeof() 求 字 节 数 的 运 算 符 结 构 体 变 量 的 长 度 是 其 内 部 成 员 总 长 度 之 和, 本 题 中,struct date 中 包 含 year, month,day 3 个 整 型 变 量 一 个 整 型 变 量 所 占 的 字 节 数 为 2, 注 意 和 共 用 体 的 差 别, 因 此 本 题 的 正 确 答 案 为 A 14. 有 以 下 程 序 : struct STU char num[10] ; float score[3] ; main ( ) struct STU s[3]= 20021, 90, 95,85, 20022, 95,80,75, 20023, 100, 95, 90, *p=s ; int i ; float sum=0 ; for ( i=0 ; i<3 ; i++) sum = sum+p->socre[i] ; printf ( % 6.2f\n, sum ); 程 序 运 行 后 的 输 出 结 果 是 A B C D 分 析 给 结 构 体 数 组 赋 初 值 时, 由 于 数 组 中 的 每 个 元 素 都 是 一 个 结 构 体, 因 此 要 将 其 成 员 的 值 依 次 放 在 一 对 花 括 号 中, 以 便 区 分 个 元 素 S[0]= 20021,90,95,85, s[1]= 20022,95,80,75,s[2]= 20023,100,95,90, 因 此 本 题 的 正 确 答 案 为 B 15. 设 有 如 下 定 义 : struct sk int a; float b ; data ; int *p; 若 要 使 p 指 向 data 中 的 a 域, 正 确 的 赋 值 语 句 是 A.p=&a ; B.p=data.a ; C.p=&data.a ; D.*p=data.a ; 分 析 结 构 体 变 量 的 应 用 方 法 有 3 种 :1) 结 构 体 变 量 名. 成 员 名 ;2) 指 针 变 量 名 -> 成 员 名 ;3)( * 指 针 变 量 名 ). 成 员 名 因 为 p 是 指 针 变 量, 所 以 应 将 地 址 值 赋 给 p 因 此 本 104

105 题 的 正 确 答 案 为 C 16. 以 下 程 序 的 输 出 结 果 是 union myun struct int x, y, z ; u ; int k ; a ; main( ) a.u.x =4 ; a.u.y=5 ; a.u.z=6 ; a,k=0 ; printf( %d\n, a.u.x) ; A.4 B.5 C.6 D.0 分 析 共 用 体 变 量 中 起 作 用 的 成 员 是 最 后 一 次 存 放 的 成 员, 在 存 入 一 个 新 的 成 员 后 原 有 的 成 员 就 失 去 作 用 在 本 题 中, 当 对 a.u.y 成 员 赋 值 时,a.u.x 的 值 就 不 存 在 了, 当 对 a.u.z 赋 值 时,a.u.y 的 值 就 不 存 在 了 因 此 本 题 的 正 确 答 案 为 D 17. 有 以 下 程 序 ; union unsigned int n; unsigned char c; u1; u1.c= A ; printf( %c\n, u1.n); 执 行 后 输 出 结 果 是 A. 产 生 语 法 错 B. 随 机 值 C.A D.65 分 析 共 用 体 变 量 中 所 有 成 员 共 享 一 段 存 储 空 间, 它 们 的 值 为 最 后 一 次 对 其 中 变 量 所 赋 的 值 因 此 本 题 的 正 确 答 案 为 C 18. 以 下 程 序 的 执 行 结 果 是 #include <stdio.h> union un int i; char c[2] ; main ( ) 105

106 union un x ; x.c[0]=10 ; x.c[1]=1 ; printf( \n%d, x.i) ; A.266 B.11 C.265 D.138 分 析 此 题 考 查 共 用 体 的 特 征 Int 类 型 变 量 I 和 字 符 数 组 c 共 用 2 个 字 节 的 存 储 单 元, 通 常 c[0] 位 于 低 字 节,c[1] 位 于 高 字 节 因 此,x.i=x.c[1] * x.c[0]=266 因 此 本 题 的 正 确 答 案 为 A 19. 已 知 字 符 0 的 ASCII 代 码 值 的 十 进 制 数 是 48, 以 下 程 序 : #include <stdio.h> main( ) union int i[2] ; long k; char c[4] ; r, *s=&r; s->i[0]=0x39 ; s->i[1]=0x38 ; printf( %x\n, s->c[0]); 其 输 出 结 果 是 A.39 B.9 C.38 D.8 分 析 共 用 体 变 量 中, 所 有 成 员 共 用 存 储 空 间, 因 此 变 量 r 中, 成 员 i[0] 和 成 员 c[0] 和 c[1] 共 用 2 个 字 节 的 存 储 空 间 ;c[0] 和 c[1] 都 占 1 个 自 己, 因 此,c[0] 与 i[0] 的 低 8 位 共 用 1 个 字 节, 而 c[1] 与 i[0] 的 高 8 位 共 用 1 个 字 节 程 序 以 十 六 进 制 数 的 形 式 输 出 s->c[0] 的 值, 因 此 我 们 只 需 求 出 在 i[0] 的 低 8 位 中 的 值 即 可 程 序 有 赋 值 语 句 : s->i[0]=0x39;s-i[i]=0x38;, 根 据 以 上 分 析, 我 们 只 需 关 心 语 句 s->i[0]=0x39 ; 的 赋 值 即 可 因 为 c[0] 与 i[0] 的 低 8 位 共 用 1 个 字 节, 所 以 s->c[0] 的 十 六 进 制 数 就 是 39 因 此 本 题 的 正 确 答 案 为 A. 20. 以 下 程 序 的 输 出 结 果 是 #include <stdio.h> typedef union long x[2] ; int y[4] ; char z[8] ; MYTYPE ; MYTYPE them ; main( ) printf ("%d\n",sizeof(them)) ; A.32 B.16 C.8 D.24 分 析 该 程 序 说 明 了 一 个 共 用 体 类 型 MYTYPE, 并 定 义 了 them 为 MYTYPE 类 型 的 共 用 体 变 量 程 序 要 求 输 出 变 量 them 所 占 的 字 节 数 共 用 体 中 包 含 3 个 成 员, 而 每 个 成 员 所 占 的 字 节 数 都 是 8, 共 用 体 变 量 所 占 内 存 字 节 数 与 其 成 员 中 占 字 节 数 最 多 的 那 个 成 员 相 等 因 106

107 此 本 题 的 正 确 答 案 为 C 21. 以 下 程 序 输 出 结 果 是 #include <stdio.h> typedef union long I ; int k[5] ; char c ; DATE ; struct date int cat ; DATE cow ; Double dog ; too ; DATE max ; main( ) printf("%d\n",sizeof(struct date) + sizeof (max)) ; A.25 B.30 C.18 D.8 分 析 该 程 序 说 明 了 一 个 名 DATE 的 共 用 体 类 型, 并 定 义 了 一 个 DATE 类 型 的 变 量 max 该 程 序 还 说 明 了 一 个 结 构 体 struct date, 在 此 结 构 体 中 含 有 一 个 DATE 类 型 的 成 员 程 序 输 出 结 构 体 struct date 类 型 的 字 节 数 与 共 用 体 的 变 量 max 的 字 节 数 之 和 共 用 体 类 型 所 占 字 节 数 由 占 字 节 数 最 多 的 成 员 确 定, 在 DATE 类 型 的 饿 成 员 中 成 员 数 组 k 占 字 节 数 最 多 为 10 个 字 节 结 构 体 struct date 类 型 的 成 员 中,cat 占 2 个 字 节,dog 占 8 个 字 节,DATE 类 型 的 成 员 cow 占 10 个 字 节, 因 此 共 占 20 个 字 节 所 以 本 题 的 正 确 答 案 为 B 22. 利 用 共 用 体 的 特 点 分 别 取 出 int 变 量 中 高 字 节 和 低 字 节 中 的 两 个 数 请 填 空 #include <stio.h> union change char c[2] ; int i; un ; main( ) un.i=26984 ; printf("%d, %c\n",un.c[0], un.c[0]) ; printf("%d, %c\n",un.c[1],un.c[1]); 运 行 本 程 序, 输 出 结 果 为 答 案 104,h 105,i 分 析 由 于 共 用 体 变 量 un 中 包 含 两 个 成 员 字 符 数 组 c 和 整 型 变 量 i, 它 们 都 占 两 个 字 节 的 存 储 单 元 由 于 是 共 用 体 存 储 单 元, 给 成 员 i 赋 值 当 给 成 员 un.i 赋 值

108 后, 系 统 将 按 int 把 数 据 存 放 在 内 存 中,un.c[1],un.c[0] 分 别 对 应 整 型 数 的 高 字 节 与 低 字 节 当 分 别 输 出 un.c[1],un.c[0] 时, 就 完 成 了 把 一 个 int 数 据 按 高 字 节 和 低 字 节 输 出 的 操 作 的 二 进 制 数 形 式 为 有 以 下 程 序 : # include <stdlib.h> main ( ) char *p,*q ; p = (char) malloc(sizeof (char)20) ; q = p ; scanf ("%s%s",p,q ); printf("%s%s\n",p,q) ; 若 从 键 盘 输 入 :abc def< 回 车 >, 则 输 出 结 果 是 A.def def B.abc def C.abc d D.d d 分 析 本 题 考 查 了 malloc 函 数 的 使 用 方 法, 此 处 了 sizeof 函 数 来 确 定 分 配 的 字 节 数, 这 是 常 见 的 应 用, 函 数 的 算 法 思 想 不 难 当 把 p 指 针 的 地 址 赋 值 给 了 q 指 针 后, 输 出 的 就 是 def 24. 已 有 定 义 如 下 : struct node int data ; struct node *next ; *p ; 以 下 语 句 调 用 malloc( ) 函 数, 使 指 针 p 指 向 一 个 具 有 struct node 类 型 的 动 态 存 储 空 间 请 填 空 p= ( struct node *) malloc ( ) 答 案 sizeof ( struct node) 分 析 本 题 考 查 了 结 点 的 动 态 申 请 动 态 申 请 需 用 到 的 函 数 为 malloc( ),malloc( ) 中 的 参 数 应 为 结 点 占 用 的 存 储 空 间 的 大 小, 此 题 申 请 的 结 点 要 用 来 存 放 struct node 类 型 的 数 据, 因 此 申 请 的 节 点 大 小 恰 好 可 以 存 放 struct node 类 型 的 数 据 而 sizeof( ) 函 数 的 作 用 是 求 得 类 型 或 数 据 占 用 的 存 储 空 间 的 大 小 25. 设 有 如 下 说 明 : struct description int len ; char *str ; ; struct description s[ ]= 0, "abcdef",1, "ABCDEF"; strcut description *p = s; 请 在 下 列 各 小 题 前 面 的 空 白 处 填 入 相 应 表 达 式 的 值 ( )( 1)++p->len ( )( 2)p->len++ 108

109 ( )( 3)(++p)->len ( )( 4)(p++)->len ( )( 5)++*p->str ( )( 6)*p->str++ ( )( 7)(*p->str)++ ( )( 8)*p++->str ( )( 9)*++p->str ( )( 10)*(++p)->str 答 案 (1) 1 (2) 0 (3) 1 (4)0 (5) b (6) a (7) 2 (8) a (9) b (10) A 解 析 本 题 实 际 上 不 需 要 计 算, 关 键 在 于 按 位 运 算 符 的 优 先 级 顺 序 逐 步 理 解 表 达 式, 弄 清 最 终 引 用 的 是 哪 一 个 数 据 对 象 此 外, 在 写 结 果 时 应 注 意 反 映 结 果 的 类 型, 例 如, 假 定 引 用 的 是 字 符 串 abcdef 中 的 第 0 个 字 符, 如 果 结 果 类 型 是 字 符 型 则 应 写 成 a ; 如 果 结 果 类 型 是 整 型 则 应 写 成 字 符 a 的 字 符 码 97 (1)-> 的 优 先 级 高 于 ++ P->len 的 结 果 即 s[0].len,++p->len 的 结 果 是 对 s[0].len 增 加 1 之 后 的 结 果 (2) 运 算 符 的 优 先 级 情 况 同 (1) 由 于 后 缀 式 ++ 运 算 符 的 延 迟,p->len++ 的 结 果 是 对 s[0].len 增 加 1 之 前 的 结 果 (3) 由 于 () 的 优 先 级 最 高, 所 以 (++) 运 算 优 先 于 -> (++p)->len 的 结 果 是 指 针 p 加 1 之 后 所 指 对 象 ( 即 s[1]) 的 成 员 len (4) 运 算 符 的 优 先 级 情 况 同 (3), 但 由 于 后 缀 式 ++ 运 算 的 延 迟,(p++)->len 的 结 果 是 p 加 1 之 前 所 指 对 象 ( 即 s[0]) 的 成 员 len 在 引 用 s[0].len 之 后 p 加 1( 指 向 s[1]) (5)-> 的 优 先 级 高 于 * 和 ++,* 和 ++ 为 右 结 合 p->str 的 结 果 即 s[0].str,*p->str 的 结 果 是 s[0].str 所 指 向 的 字 符,++*p->str 的 结 果 是 s[0].str 所 指 向 的 字 符 增 1 (6)-> 的 优 先 级 高 于 * 和 ++,* 和 ++ 为 同 一 优 先 级 右 结 合 的 运 算 符 所 以 此 题 的 运 算 次 序 为 :-> 最 先,++ 其 次 (++ 作 用 于 p 指 向 的 str 上 ),* 最 后 (* 也 作 用 于 p->str 上 ) 但 由 于 ++ 为 后 缀 延 迟 运 算, 因 此 *p->str++ 的 结 果 是 s[0].str 所 指 字 符 串 的 第 0 个 字 符 在 完 成 * 运 算 后 s[0].str 加 1( 指 向 该 串 的 下 一 个 字 符 ) (7)-> 首 先 运 算 ; 由 于 () 的 优 先 级 高, 所 以 () 中 的 * 运 算 优 先 于 ++ 运 算 (*p->str) ++ 和 (6) 题 的 结 果 一 样, 不 同 的 是 (6) 题 中 的 ++ 是 使 s[0].str 加 1, 而 本 题 是 使 s[0].str 所 指 的 对 象 加 1 (8), 按 照 ++ 和 -> 运 算 表 达 式 的 语 法,-> 的 左 操 作 数 不 可 能 是 ++, 而 ++ 的 操 作 数 也 不 可 能 是 str, 因 此 ++ 是 使 p 加 1 由 于 ++ 为 后 缀 延 迟 运 算, 所 以 *p++->str 的 运 算 次 序 依 次 为 -> * 和 ++, 其 结 果 为 s[0].str 所 指 向 的 字 符 ( 在 完 成 * 运 算 之 后 p 增 加 1) (9), 表 面 上 与 (8) 题 类 似, 但 二 者 运 算 情 况 却 完 成 不 同 首 先,++ 运 算 符 与 操 作 数 之 间 的 关 系 与 第 (8) 题 不 同, 本 题 的 ++ 是 使 p 所 指 向 的 str 增 加 1, 而 第 8 题 中 的 ++ 是 使 p 增 加 1 其 次,p++->str 是 引 用 p 当 前 所 指 的 元 素 ( 即 s[0]) 的 str, 而 ++p 是 引 用 p 增 1 之 后 所 指 向 的 元 素 ( 即 s[1]) 的 str (10), 由 于 () 的 优 先 级 最 高, 各 运 算 符 的 优 先 次 序 依 次 为 (++) -> 和 *, 所 以 *(++p) ->str 的 结 果 是 s[1].str 所 指 向 的 字 符 26. 假 定 输 入 数 据 是 字 符 串 abcdefghijk, 请 写 出 程 序 的 输 出 结 果 #include <stdio.h> #include<ctype.h> #include<stdlib.h> struct node 109

110 char ch; struct node *next ; ; void main (void) int c ; struct node *head=null, *p ; printf("input a string : "); while ( isspace(c=getchar())); for (; c!= \n && c!=eof ; c=getchar()) p=(struct node *)malloc(sizeof(struct node *)) ; p->ch = c ; p->next =head ; head=p; for (p=head ; p!=null ; p=p->next) printf("%c",p->ch ); printf("\n") ; 答 案 kjihgfedcba 分 析 程 序 在 跳 过 开 头 的 空 白 字 符 后, 一 边 读 入 字 符, 一 边 将 所 读 入 的 字 符 存 入 所 建 立 的 链 表 中, 直 到 遇 到 行 结 束 符 或 文 件 尾 为 止 程 序 输 入 的 字 符 被 存 放 在 一 个 先 进 后 出 的 的 链 表 中 27. 以 下 程 序 的 输 出 结 果 是 A B C D. 输 出 不 定 值 #include "alloc.h" fun(float *p1,float *p2, float *s) s = (float *) calloc ( 1, sizeof(float)) ; *s = *p1 + *(p2++) ; main ( ) float a[2] = 1,1, 2.2, b[2] = 10.0, 20.0, *w ; fun (a, b, w ) ; printf ("%5.2f\n", *w) ; 分 析 C 语 言 规 定, 实 参 与 形 参 之 间 只 能 进 行 按 值 传 递, 对 应 的 实 参 和 形 参 分 别 占 用 不 同 的 存 储 单 元 ; 因 此, 形 参 的 任 何 改 变, 不 影 响 主 调 函 数 实 参 的 值 当 被 调 用 函 数 运 行 结 束 时, 形 参 及 函 数 内 的 变 量 全 部 小 时 ( 释 放 ) 因 此, 当 调 用 fun 函 数 时, 数 组 a b 的 首 地 址 分 别 传 递 给 p1 和 p2, 因 此 p1 和 p2 分 别 指 向 a[0] 和 b[0] 同 样, 被 调 函 数 的 形 参 s 也 接 受 主 调 函 数 的 实 际 参 数 w 的 值, 但 w 中 无 确 定 的 地 址 值, 即, 无 具 体 的 指 向, 因 此 形 参 s 也 无 确 定 的 值 在 fun 函 数 内, 通 过 动 态 分 配, 是 s 指 向 了 一 个 动 态 分 配 的 存 储 空 间, 并 通 过 表 达 式 给 此 存 储 单 元 赋 了 值 (11.1); 但 这 一 切 仅 仅 是 使 得 fun() 函 数 内 形 参 s 有 了 具 体 的 地 址 值, 而 未 影 响 到 主 调 函 数 中 的 实 参 w, 这 个 动 态 分 配 的 空 间 的 地 址 也 没 有 以 任 何 形 式 返 回 给 110

111 主 调 函 数, 因 此, 当 被 调 函 数 结 束 时, 形 参 s 消 失, 主 函 数 的 实 参 w 仍 然 没 有 明 确 指 向 哪 一 个 空 间, 也 未 指 向 动 态 分 配 的 空 间, 因 此,*w 的 值 不 定 根 据 以 上 分 析, 本 题 的 正 确 答 案 为 D 28. 设 有 以 下 结 构 类 型 的 说 明 和 变 量 定 义 : struct stud char num[5] ; int s[4] ; double ave ; a, *p ; 则 变 量 a 在 内 存 所 占 字 节 数 是 (1) ; 变 量 p 在 内 存 所 占 字 节 数 是 (2) 答 案 (1)21 (2) 2 分 析 本 题 中 a 是 一 个 名 为 struct stud 结 构 体 类 型 的 变 量 该 结 构 体 中 有 三 个 成 员 : 一 个 是 字 符 数 组 num, 它 有 5 个 元 素, 每 个 元 素 占 一 个 字 节, 共 占 5 个 字 节 ; 第 二 个 成 员 s 是 一 个 整 型 数 组, 它 含 有 4 个 元 素, 每 个 元 素 占 两 个 字 节, 共 占 8 个 字 节 ; 第 三 个 成 员 ave 为 双 精 度 型, 占 8 个 字 节 加 起 来 共 21 个 字 节 因 此 (1) 处 应 填 21 对 于 变 量 p, 它 是 一 个 基 类 型 struct stu 结 构 体 的 指 针 变 量, 用 于 存 放 struct stud 类 型 变 量 的 地 址, 而 作 为 变 量 的 地 址 是 由 16 位 二 进 制 数 表 示 的, 因 而 只 需 两 个 字 节 即 可 存 放 任 一 地 址 值, 所 以 系 统 将 为 p 分 配 两 个 字 节 的 存 储 单 元, 即 (2) 处 应 填 若 有 以 下 说 明 和 语 句, 则 值 为 6 的 表 达 式 是 D A.p++->n B.p->n++ C.(*p).n++ D.++p->n struct st int n ; struct st *next ; struct st a[3], *p ; a[0].n=5 ; a[0].next = &a[1] ; a[1].n=7 ; a[1].next = &a[2] ; a[2].n=9 ; a[0].next = \n ; p=&a[0]; 分 析 本 题 中 说 明 了 一 个 名 struct st 的 结 构 体, 它 有 两 个 成 员 : 一 个 是 整 型 成 员 n; 一 个 是 指 针 成 员 next, 它 的 基 类 型 是 它 所 在 的 结 构 类 型 接 着 又 定 义 了 类 型 为 该 结 构 体 一 维 数 组 a 和 指 针 标 量 p a 数 组 含 有 3 个 元 素 并 通 过 后 面 的 赋 值 语 句 对 它 们 进 行 编 辑 p 指 向 a 数 组 的 第 一 个 元 素 在 选 项 A 中, 运 算 符 > 是 一 个 双 目 运 算 符, 其 左 边 的 运 算 量 是 一 个 表 达 式 p++, 由 于 是 后 缀 形 式 的 自 加 运 算, 所 以 表 达 式 p++ 的 值 仍 为 p 所 指 元 素 a[0] 的 地 址, 因 此 p++->n 的 值 就 是 a[0].n 中 的 值 5, 然 后 再 使 p 指 向 下 一 个 元 素 a[1], 因 此 表 达 式 p++->n 的 值 是 5 选 项 B 中, 由 于 -> 的 优 先 级 高 于 ++,p->n 是 一 个 整 体, 引 用 的 是 a[0].n, 由 于 ++ 是 后 缀 运 算 符, 所 以 先 取 p->n (a[0],n.) 加 1, 变 成 6 选 项 C 中 的 表 达 式 是 选 项 B 中 表 达 式 的 另 一 种 表 示 形 式, 因 此 表 达 式 的 值 也 是 5 而 选 项 D 中 由 于 采 用 的 是 前 缀 形 式 的 自 加 运 算, 所 以 先 取 p->n 的 值 然 后 加 1, 再 将 加 1 后 的 值 ( 整 数 6) 作 为 表 达 式 的 值 并 存 入 a[0].n, 所 以 本 题 的 正 确 答 案 应 为 D 练 一 练 一 单 选 题 1. 以 下 对 结 构 体 类 型 变 量 td 的 定 义 中, 错 误 的 是 111

112 A. typedef struct aa int n; float m; AA; AA td1; B. #define AA struct aa AA int n; float m; td1 ; C. struct int n; float m; aa; struct aa td ; D.struct aa int n; float m; td1 ; 2. 以 下 选 项 中 不 能 正 确 把 cl 定 义 成 结 构 体 变 量 的 是 A. typedef struct int red; int green; int blue; COLOR; B. struct color cl int red; int green; int blue; ; COLOR cl; C. struct color int red; int green; int blue; cl; D. struct int red; int green; int blue; cl; 3. 有 以 下 结 构 体 说 明 和 变 量 定 义, 如 图 4-7 所 示, 指 针 p q r 分 别 指 向 一 个 链 表 中 的 三 个 连 续 结 点 struct node 112

113 int data; struct node *next; *p, *q, *r; data next data next data next p q r 图 4-7 本 题 结 构 的 示 意 图 现 要 将 q 和 r 所 指 结 点 的 先 后 位 置 交 换, 同 时 要 保 持 链 表 的 连 续, 以 下 错 误 的 程 序 段 是 A. r->next=q; q->next=r->next; p->next=r; B. q->next=r->next; p->next=r; r->next=q; C. p->next=r; q->next=r->next; r->next=q; D. q->next=r->next; r->next=q; p->next=r; 4. 有 以 下 程 序 struct STU char name[10]; int num; int Score; ; main( ) struct STU s[5]= "YangSan",20041,703,"LiSiGuo",20042,580, "wangyin",20043,680,"sundan",20044,550, "Penghua",20045,537,*p[5],*t; int i,j; for(i=0;i<5;i++) p[i]=&s[i]; for(i=0;i<4;i++) for(j=i+1;j<5;j++) if(p[i ]->Score>p[j]->Score) t=p[i];p[i]=p[j];p[j]=t; printf("5d %d\n",s[1].score,p[1]->score); A B C D 设 有 如 下 定 义 : struck sk int a; float b; data; int *p; 113

114 P 指 向 data 中 的 a 域, 正 确 的 赋 值 语 句 是 A.p=&a; B. p=data.a; C. p=&data.a; D. *p=data.a; 6. 有 以 下 程 序 #include struct NODE int num; struct NODE *next; ; struct NODE *p,*q,*r; p=(struct NODE*)malloc(sizeof(struct NODE)); q=(struct NODE*)malloc(sizeof(struct NODE)); r=(struct NODE*)malloc(sizeof(struct NODE)); p->num=10; q->num=20; r->num=30; p->next=q;q->next=r; printf("%d\n",p->num+q->next->num); A. 10 B.20 C. 30 D 若 有 以 下 说 明 和 定 义 typedef int *INTEGER; INTEGER p,*q; A P 是 int 型 变 量 B p 是 基 类 型 为 int 的 指 针 变 量 C q 是 基 类 型 为 int 的 指 针 变 量 D 程 序 中 可 用 INTEGER 代 替 int 类 型 名 8. 以 下 程 序 的 输 出 结 果 是 union myun struct int x, y, z; u; int k; a; a.u.x=4; a.u.y=5; a.u.z=6; a.k=0; printf("%d\n",a.u.x); A. 4 B.5 C. 6 D. 0 二 填 空 题 (4 分 ) 1. 以 下 定 义 的 结 构 体 类 型 拟 包 含 两 个 成 员, 其 中 成 员 变 量 info 用 来 存 入 整 形 数 据 ; 成 员 变 量 link 是 指 向 自 身 结 构 体 的 指 针. 请 将 定 义 补 充 完 整 struct node int info; link; 114

115 2. 以 下 程 序 段 用 于 构 成 一 个 简 单 的 单 向 链 表, 请 填 空 struct STRU int x, y ; float rate; p; a, b; a.x=0; a.y=0; a.rate=0; a.p=&b; b.x=0; b.y=0; b.rate=0; b.p=null; 3. 若 有 如 下 结 构 体 说 明 : struct STRU int a, b ; char c; double d: struct STRU p1,p2; ; t 数 组 的 定 义,t 数 组 的 每 个 元 素 为 该 结 构 体 类 型 t ; 4. 有 如 下 定 义 struct personchar name[9]; int age;; strict person class[10]= "Johu", 17, "Paul", 19 "Mary", 18, "Adam", 16,; M 的 语 句 是 三 程 序 调 试 题 ( 下 列 各 程 序 中 存 在 一 些 问 题, 通 过 调 试 发 现 问 题, 并 加 以 修 正, 使 其 实 现 预 期 目 标 ) 1. 下 列 程 序 的 功 能 为 : 学 生 姓 名 (name) 和 年 龄 (age) 存 于 结 构 体 数 组 person 中, 函 数 fun 的 功 能 是 : 找 出 年 龄 最 小 的 那 名 学 生, 请 纠 正 程 序 中 存 在 的 错 误, 使 程 序 实 现 其 功 能 程 序 3.1 #include<stdio.h> struct stud char name[20]; ; int age; fun(struct stud person[],int n) int min,i; min=0; for(i=0;i<n;i++) if(person[i] <person[min] ) return (person ); void min=i; 115

116 struct stud a[]="zhao",21,"qian",20,"sun",19,"li",22; int n=4; struct stud minpers; minpers=fun(a,n); printf("%s 是 年 龄 小 者, 年 龄 是 :%d\n",minpers.name,minpers.age); 2. 下 列 程 序 的 功 能 为 : 应 用 结 构 体 求 多 项 式 的 值 多 项 式 : a n x n +a n-1 x n-1 +a n-2 x n-2 + +a 1 x+a 0, 请 纠 正 程 序 中 存 在 的 错 误, 使 程 序 实 现 其 功 能 程 序 3.2 #include<stdio.h> #include<math.h> struct Poly float a; /* 系 数 */ ; int n; /* 指 数 */ double fpvalue() struct Poly p; double pvalue=0; float x; printf(" 输 入 多 项 式 X:\n"); scanf("%f",&x); printf(" 输 入 多 项 式 系 数 (a) 和 指 数 ( n,n=-10000, 结 束 ):\n"); scanf("%f %d", p.a, p.n); while(p.n!=-10000) pvalue+=p.a*pow(x, n); scanf("%f %d", p.a, p.n); return pvalue; void printf(" 多 项 式 值 :%20.8f\n",fpvalue()); 四 程 序 填 空 题 ( 请 填 写 适 当 的 符 号, 使 程 序 实 现 其 功 能 ) 1 下 列 函 数 findbook 的 功 能 为 : 在 有 n 个 元 素 的 数 组 s 中 查 找 书 名 为 a 的 书, 若 找 到, 函 数 返 回 数 组 下 标, 否 则, 函 数 返 回 -1, 请 填 写 适 当 的 符 号 或 语 句, 使 程 序 实 现 其 功 能 程 序 4.1 #include<stdio.h> struct bdata int id; char bname[20]; float price; 116

117 int findbook(struct bdata st[],int n,char s[]) int i; for(i=0;i<n;i++) if( ) return i; ; void struct bdata book[100]; char st[20]; int index; printf(" 请 输 入 要 查 找 书 名 :"; gets(st); index=findbook( ); 下 列 函 数 average 功 能 为 : 计 算 5 名 学 生 3 门 课 成 绩 的 平 均 分, 请 填 写 适 当 的 符 号 或 语 句, 使 程 序 实 现 其 功 能 程 序 4.2 #include<stdio.h> #define m 3 #define n 5 struct stud int no; char name[16]; float mark[m]; float ave; ; void average(struct stud st[]) int i,j; float sum; for(i=0;i<n;i++) sum= ; for(j=0;j<m;j++) sum= ; =sum/m; void struct stud int i,j; preson[n]; 117

118 for(i=0;i<n;i++) printf(" 输 入 学 生 的 学 号 \n"); scanf("%d",&preson[i].no);getchar(); printf(" 输 入 学 生 的 姓 名 \n"); gets(preson[i].name); for(j=0;j<m;j++) printf("%d 同 学 第 %d 门 课 程 的 成 绩 \n",preson[i].no,j+1); scanf("%f",& preson[i].mark[j]); average(preson); printf(" 成 绩 单 \n 学 号 姓 名 成 绩 1 成 绩 2 成 绩 3 平 均 分 \n"); for(i=0;i<n;i++) printf("%d %10s", preson[i].no,preson[i].name); for(j=0;j<m;j++) printf(" %10.1f", preson[i].mark[j]); printf("%10.1f\n", preson[i].ave); 五 编 程 1. 编 写 一 个 程 序 实 现 如 下 功 能 : 有 4 名 学 生, 每 个 学 生 信 息 包 含 学 号 姓 名 数 学 成 绩 英 语 成 绩 C 语 言 成 绩 和 三 门 课 程 的 总 分, 并 对 数 据 进 行 输 入 和 输 出 ( 程 序 以 文 件 名 sy8_7.c 存 盘 ) 2. 编 写 一 个 程 序 实 现 如 下 功 能 : 定 义 一 个 点 的 结 构 数 据 类 型, 实 现 下 列 功 能 : 1 为 点 输 入 坐 标 值 2 求 两 个 点 中 点 坐 标 118

119 第 5 章 数 据 文 件 文 件 也 是 C 语 言 提 供 的 一 种 数 据 类 型 但 它 不 同 于 变 量 数 组 结 构 体 类 型 变 量 指 针 变 量, 它 是 基 于 外 部 介 质 上 的 数 据 类 型, 使 用 文 件 可 以 实 现 数 据 的 持 久 化, 使 数 据 完 全 独 立 图 5-1 文 件 知 识 网 络 图 5.1 数 据 文 件 的 函 数 为 了 记 录 计 算 机 的 运 算 结 果, 并 且 保 证 在 断 点 状 态 下 数 据 依 然 可 以 被 保 存, 所 以 将 数 据 记 录 在 介 质 上, 通 常 意 义 上 这 些 介 质 指 硬 盘, 利 用 硬 盘 的 存 储 特 性, 携 带 数 据 并 且 长 久 的 保 存 数 据, 我 们 把 这 些 介 质 上 的 数 据 集 合 称 为 文 件 在 C 语 言 中, 文 件 分 为 文 本 形 式 和 二 进 制 方 式, 这 2 类 文 件 都 是 顺 序 存 放, 都 可 以 顺 序 读 取 或 者 写 入 对 于 计 算 机 系 统 来 说 最 常 用 的 是 文 本 文 件, 所 谓 文 本 文 件 实 际 上 是 数 据 按 照 其 面 值 转 换 为 字 符, 每 个 字 符 对 应 一 个 ASCII 码 存 储 到 文 件 中, 一 个 字 符 占 用 一 个 字 节 所 谓 二 进 制 方 式, 数 据 按 照 二 进 制 方 式 直 接 输 出 到 文 件 中, 数 据 不 经 过 任 何 转 换, 按 照 计 算 机 内 内 存 形 式 直 接 存 放, 对 于 不 同 的 数 据 类 型 占 用 不 同 的 字 节 不 能 直 接 从 键 盘 获 得 二 进 制 数 据, 要 获 得 二 进 制 数 据 必 须 通 过 内 存 文 件 在 输 入 和 输 出 时 有 缓 冲 区 的 概 念, 缓 冲 区 存 放 在 内 存 中, 从 硬 盘 获 得 数 据 要 经 过 缓 冲 区 才 可 以 被 程 序 获 得, 程 序 要 写 入 硬 盘 的 数 据 也 必 须 经 过 缓 冲 区 文 件 指 针 文 件 指 针 是 基 于 系 统 文 件 结 构 体 FILE 定 义 的 指 针, 该 系 统 结 构 体 被 定 义 在 stdio.h 头 文 件 中, 用 来 存 放 文 件 的 相 关 重 要 信 息 如 :FILE *fp; 定 义 了 文 件 指 针 fp,file 做 为 系 统 定 义 的 结 构 体 必 须 大 写 119

120 5.1.2 文 件 打 开 与 关 闭 1 文 件 打 开 函 数 fopen fopen 函 数 用 来 打 开 一 个 文 件, 其 调 用 的 一 般 形 式 为 : 文 件 指 针 名 =fopen( 文 件 名, 使 用 文 件 方 式 ) 其 中, 文 件 指 针 名 必 须 是 被 说 明 为 FILE 类 型 的 指 针 变 量, 文 件 名 是 被 打 开 文 件 的 文 件 名 使 用 文 件 方 式 是 指 文 件 的 类 型 和 操 作 要 求 文 件 名 是 字 符 串 常 量 或 字 符 串 数 组 例 如 : FILE *fp; fp=("file1.dat","r"); 其 意 义 是 在 当 前 目 录 下 打 开 文 件 file1, 只 允 许 进 行 读 操 作, 并 使 fp 指 向 该 文 件 对 于 文 件 使 用 方 式 有 以 下 几 点 说 明 : 文 件 使 用 方 式 由 表 5-1 所 示 : 表 5-1 文 件 的 使 用 方 式 文 件 类 型 使 用 方 式 含 义 w 文 件 只 允 许 写, 不 允 许 读 r 文 件 只 允 许 读, 不 允 许 写 ASCII 文 件 a 只 允 许 在 文 件 尾 部 写 w+ 文 件 允 许 写, 也 允 许 读, 必 须 先 写 后 读 r+ 文 件 允 许 读, 也 允 许 写, a+ 文 件 允 许 读, 允 许 在 尾 部 写 wb 文 件 只 允 许 写, 不 允 许 读 rb 文 件 只 允 许 读, 不 允 许 写 二 进 制 文 件 ab 只 允 许 在 文 件 尾 部 写 wb+ 文 件 允 许 写, 也 允 许 读, 必 须 先 写 后 读 rb+ 文 件 允 许 读, 也 允 许 写, ab+ 文 件 允 许 读, 允 许 在 尾 部 写 2 fclose( 文 件 指 针 ) fclose(fp) 正 常 完 成 关 闭 文 件 操 作 时,fclose 函 数 返 回 值 为 0 如 果 返 回 值 为 非 零, 则 表 示 有 错 误 发 生 文 件 的 读 写 是 最 常 用 的 文 件 操 作 文 件 定 位 文 件 一 旦 被 正 确 打 开, 就 会 有 一 个 指 针 指 向 该 文 件 开 始 处, 以 便 对 文 件 操 作 在 对 文 件 每 执 行 一 次 读 或 写 操 作, 指 针 就 后 移 到 下 一 个 读 写 位 置, 为 下 一 次 操 作 做 准 备, 这 种 读 写 方 式 称 为 顺 序 读 写 但 是 实 际 应 用 中 往 往 需 要 对 文 件 随 机 读 写, 这 就 需 要 将 文 件 指 针 人 为 的 移 动 到 所 希 望 的 位 置 处, 因 此,C 语 言 提 供 移 动 文 件 指 针 的 两 个 函 数, 即 rewind 函 数 和 fseek 函 数 1 rewind 函 数 其 调 用 形 式 为 :rewind( 文 件 指 针 ); 它 的 功 能 是 把 文 件 内 部 的 位 置 指 针 移 到 文 件 首 2 fseek 函 数 fseek 函 数 用 来 移 动 文 件 内 部 位 置 指 针, 其 调 用 形 式 为 : 120

121 fseek( 文 件 指 针, 位 移 量, 起 始 点 ); 其 中 : 文 件 指 针 指 向 被 移 动 的 文 件 位 移 量 表 示 移 动 的 字 节 数, 要 求 位 移 量 是 long 型 数 据, 以 便 在 文 件 长 度 大 于 64KB 时 不 会 出 错 当 用 常 量 表 示 位 移 量 时, 要 求 加 后 缀 L 起 始 点 表 示 从 何 处 开 始 计 算 位 移 量, 起 始 点 规 定 有 三 种 : 文 件 开 始 ( 值 为 0) 文 件 当 前 位 置 ( 值 为 1) 和 文 件 末 尾 ( 值 为 2) 文 件 的 出 错 检 测 和 处 理 在 磁 盘 的 输 入 输 出 操 作 中, 可 能 会 出 现 各 种 各 样 的 错 误,C 语 言 提 供 了 几 个 用 于 检 查 处 理 读 写 错 误 的 函 数 1 feof 函 数 函 数 feof() 是 检 测 文 件 是 否 结 束,feof 函 数 调 用 格 式 : feof( 文 件 指 针 ); 功 能 : 判 断 文 件 是 否 处 于 文 件 结 束 位 置, 如 文 件 结 束, 则 返 回 值 为 1, 否 则 为 0 2 ferror 函 数 函 数 feeror() 是 检 测 文 件 操 作 是 否 有 错,ferror 函 数 调 用 格 式 : ferror( 文 件 指 针 ); 功 能 : 检 查 文 件 在 用 各 种 输 入 输 出 函 数 进 行 读 写 时 是 否 出 错 如 ferror 返 回 值 为 0 表 示 未 出 错, 否 则 表 示 有 错 3 clearerr 函 数 函 数 clearerr() 是 清 除 出 错 标 志 和 文 件 结 束 标 志 置 0,clearerr 函 数 调 用 格 式 : clearerr( 文 件 指 针 ); 功 能 : 本 函 数 用 于 清 除 出 错 标 志 和 文 件 结 束 标 志, 使 它 们 为 0 值 4 exit 函 数 当 文 件 操 作 出 错 时, 为 了 避 免 数 据 丢 失, 正 常 操 作 系 统, 可 以 调 用 过 程 控 制 函 数 exit 关 闭 文 件, 终 止 执 行 操 作,exit 函 数 格 式 : exit( 状 态 值 ) 功 能 : 清 除 并 关 闭 所 有 已 打 开 文 件, 写 出 文 件 缓 冲 区 中 的 所 有 数 据, 程 序 正 常 情 况 由 main 函 数 结 束 并 返 回 操 作 系 统 5.2 数 据 文 件 的 读 单 个 字 符 的 读 fgetc 函 数 的 功 能 是 从 指 定 的 文 件 中 读 一 个 字 符, 函 数 调 用 的 形 式 为 : 字 符 变 量 =fgetc( 文 件 指 针 ); 例 如 :ch=fgetc(fp); 其 意 义 是 从 打 开 的 文 件 fp 中 读 取 一 个 字 符 并 送 入 ch 中 注 意 : 1 在 fgetc 函 数 调 用 中, 读 取 的 文 件 必 须 是 以 读 或 读 写 方 式 打 开 的 121

122 2 读 取 字 符 的 结 果 也 可 以 不 向 字 符 变 量 赋 值, 例 如 :fgetc(fp) 但 是 读 出 的 字 符 不 能 保 存 3 在 文 件 内 部 有 一 个 位 置 指 针 用 来 指 向 文 件 的 当 前 读 写 字 节 在 文 件 打 开 时, 该 指 针 总 是 指 向 文 件 的 第 一 个 字 节 使 用 fgetc 函 数 后, 该 位 置 指 针 将 向 后 移 动 一 个 字 节 因 此 可 连 续 多 次 使 用 fgetc 函 数, 读 取 多 个 字 符 应 注 意 文 件 指 针 和 文 件 内 部 的 位 置 指 针 不 是 一 回 事 文 件 指 针 是 指 向 整 个 文 件 的, 须 在 程 序 中 定 义 说 明, 只 要 不 重 新 赋 值, 文 件 指 针 的 值 是 不 变 的 文 件 内 部 的 位 置 指 针 用 以 指 示 文 件 内 部 的 当 前 读 写 位 置, 每 读 写 一 次, 该 指 针 均 向 后 移 动, 它 不 需 在 程 序 中 定 义 说 明, 而 是 由 系 统 自 动 设 置 的 从 一 个 文 本 文 件 顺 序 读 入 字 符 并 在 屏 幕 上 显 示 出 来 : ch = fgetc(fp); while(ch!=eof) putchar(ch); ch = fgetc(fp); 注 意 :EOF 不 是 可 输 出 字 符, 因 此 不 能 在 屏 幕 上 显 示 由 于 字 符 的 ASCII 码 不 可 能 出 现 -1, 因 此 EOF 定 义 为 -1 是 合 适 的 当 读 入 的 字 符 值 等 于 -1 时, 表 示 读 入 的 已 不 是 正 常 的 字 符 而 是 文 件 结 束 符 字 符 串 的 读 fgets 函 数 的 功 能 是 从 文 件 读 若 干 个 字 符, 函 数 的 调 用 形 式 为 : fgets( 字 符 串 量, 长 度, 文 件 指 针 ); 注 意 : 若 还 未 到 读 完 若 干 字 符 已 遇 到 换 行 符 \n 或 文 件 结 束 符 EOF, 则 读 操 作 自 动 结 束, 并 读 到 的 换 行 符 \n 连 同 结 束 符 \0 一 起 写 入 字 符 串 中 例 如 :/* 下 面 的 这 段 代 码 作 用 在 于, 输 入 一 个 字 符 串, 然 后 计 算 出 字 符 串 中 单 词 的 个 数 */ #include<stdio.h> int char ch[80]; char t,m; int i=0,count=0,flag=0; fgets(ch,80,stdin); fputs(ch,stdout); for (i=0;ch[i]!='\0';i++) if (ch[i]==' ') flag=0; else if (flag==0) flag=1; count++; 122

123 printf("%d\n",count); return 0; 这 段 代 码 的 工 作 原 理 是, 使 用 一 个 用 于 标 识 的 变 量 flag, 还 有 一 个 用 于 统 计 单 词 个 数 的 变 量 count 然 后 逐 一 读 取 字 符 串 中 的 每 一 个 字 符, 当 遇 到 字 母 时 flag 的 值 为 1, 当 遇 到 空 格 时,flag 的 值 为 0 如 果 遇 到 一 个 字 母, 并 且 此 时 flag 值 为 0( 说 明 这 个 字 母 之 前 的 一 个 字 符 是 空 格 ), 给 count 加 1, 直 到 遇 到 空 格 时, 将 flag 重 新 赋 值 为 0 在 fgets() 使 用 中 需 要 注 意, 其 中 第 二 个 参 数 规 定 的 字 符 串 长 度 应 该 与 字 符 串 长 度 相 等, 否 则 运 行 程 序 时 会 有 溢 出 的 错 误 当 输 入 的 字 符 串 大 于 限 定 的 字 符 串 长 度 时 ( 本 例 中 限 定 的 是 80), 限 定 长 度 之 后 的 字 符 串 会 被 丢 弃 数 据 块 读 C 语 言 还 提 供 了 主 要 用 于 二 进 制 文 件 的 读 函 数 fread, 可 用 来 读 一 组 数 据, 如 一 个 数 组 元 素, 一 个 结 构 变 量 的 值 等 调 用 读 数 据 块 函 数 一 般 形 式 为 : fread(buffer,size,count,fp); 其 中 : buffer: 是 一 个 指 针 对 fread 来 说, 它 是 读 入 数 据 的 存 放 地 址 对 fwrite 来 说, 是 要 输 出 数 据 的 地 址 ( 是 指 起 始 地 址 ) size: 是 要 读 写 的 字 节 数 count: 是 要 进 行 读 写 多 少 个 size 字 节 的 数 据 项 fp: 文 件 指 针 如 果 文 件 二 进 制 形 式 打 开, 用 fread 和 fwrite 函 数 就 可 以 读 写 任 何 类 型 的 信 息 下 面 是 一 个 完 整 的 例 子 从 键 盘 输 入 4 个 学 生 的 有 关 数 据, 然 后 把 它 们 转 存 到 磁 盘 文 件 上 去, 接 着 把 它 们 输 出 到 终 端 #include <stdio.h> #define SIZE 4 struct student_type char name[20]; int num; int age; char addr[15]; stud[size]; void save() FILE * fp; int i; if ((fp = fopen("d:\\stu_list.txt", "wb")) == NULL) printf("cannot open file\n"); return; 123

124 for (i = 0; i < SIZE; i++) if(fwrite(&stud[i], sizeof(struct student_type), 1, fp)!= 1) printf("file write error.\n"); fclose(fp); void printf("sizeof(struct stud) = %d\n", sizeof(student_type)); printf("please input the 4 student information,including name,num,age,address\n"); int i; for(i = 0; i < SIZE; i++) scanf("%s%d%d%s", stud[i].name, &stud[i].num, &stud[i].age, stud[i].addr); save(); printf("\nthe information of the 4 students is:\n"); FILE* fp; fp = fopen("d:\\stu_list.txt", "rb"); for (i = 0; i < SIZE; i++) fread(&stud[i], sizeof(struct student_type), 1, fp); printf("%-10s %4d %4d %-15s\n", stud[i].name, stud[i].num, stud[i].age, stud[i].addr); fclose(fp); 格 式 化 读 fscanf 函 数 与 前 面 使 用 的 scanf 函 数 的 功 能 相 似, 都 是 格 式 化 读 写 函 数 两 者 的 区 别 在 于 fscanf 函 数 的 读 写 对 象 不 是 键 盘 和 显 示 器, 而 是 磁 盘 文 件 这 两 个 函 数 的 调 用 格 式 为 : fscanf( 文 件 指 针, 格 式 字 符 串, 输 入 表 列 ); 例 如 : fscanf(fp,"%d%s",&i,s); 5.3 数 据 文 件 的 写 单 个 字 符 的 写 fputc 函 数 的 功 能 是 把 一 个 字 符 写 入 指 定 的 文 件 中, 函 数 调 用 的 形 式 为 : 124

125 fputc( 字 符 量, 文 件 指 针 ); 其 中, 待 写 入 的 字 符 量 可 以 是 字 符 常 量 或 变 量, 例 如 :fputc('a',fp); 其 意 义 是 把 字 符 a 写 入 fp 所 指 向 的 文 件 中 注 意 : 1 被 写 入 的 文 件 可 以 用 写 读 写 和 追 加 方 式 打 开, 用 写 或 读 写 方 式 打 开 一 个 已 存 在 的 文 件 时 将 清 除 原 有 的 文 件 内 容, 写 入 字 符 从 文 件 首 开 始 如 需 保 留 原 有 文 件 内 容, 希 望 写 入 的 字 符 以 文 件 末 开 始 存 放, 必 须 以 追 加 方 式 打 开 文 件 被 写 入 的 文 件 若 不 存 在, 则 创 建 该 文 件 2 每 写 入 一 个 字 符, 文 件 内 部 位 置 指 针 向 后 移 动 一 个 字 节 3fputc 函 数 有 一 个 返 回 值, 如 写 入 成 功 则 返 回 写 入 的 字 符, 否 则 返 回 一 个 EOF 可 用 此 来 判 断 写 入 是 否 成 功 #include <stdlib.h> #include <stdio.h> void main(void) FILE *fp; char ch,filename[10]; scanf("%s",filename); if((fp=fopen(filename,"w"))==null) printf("cannot open file\n"); exit(0); /* 终 止 程 序 */ ch=getchar( ); /* 接 收 执 行 scanf 语 句 时 最 后 输 入 的 回 车 符 */ ch=getchar( ); /* 接 收 输 入 的 第 一 个 字 符 */ while(ch!='#' fputc(ch,fp);putchar(ch); ch=getchar(); fclose(fp); 运 行 情 况 如 下 : ( 输 入 磁 盘 文 件 名 ) computer and computer and c ( 输 出 一 个 字 符 串 ) 字 符 串 的 写 fputs 函 数 功 能 是 字 符 串 量 所 标 识 的 字 符 串 ( 不 包 括 结 束 符 \0 ) 写 入 由 指 针 指 向 的 文 件 中 去, 函 数 形 式 为 : fputs( 字 符 串 量, 文 件 指 针 ); 注 意 : 调 用 本 函 数 时, 若 调 用 成 功 返 回 零 值, 不 成 功 返 回 -1 例 如 : 要 求 在 string 文 件 末 加 写 字 符 串, 因 此, 在 程 序 第 6 行 以 追 加 读 写 文 本 文 件 的 方 式 打 开 文 件 string 然 后 输 入 字 符 串, 并 用 fputs 函 数 把 该 串 写 入 文 件 string 在 程 序 15 行 用 rewind 函 数 把 文 件 内 部 位 置 指 针 移 到 文 件 首 再 进 入 循 环 逐 个 显 示 当 前 文 件 中 的 全 部 内 容 #include<stdio.h> 125

126 FILE *fp; char ch,st[20]; if((fp=fopen("string","at+"))==null) printf("cannot open file strike any key exit!"); getch(); exit(1); printf("input a string:\n"); scanf("%s",st); fputs(st,fp); rewind(fp); ch=fgetc(fp); while(ch!=eof) putchar(ch); ch=fgetc(fp); printf("\n"); fclose(fp); 数 据 块 写 写 数 据 块 函 数 调 用 的 一 般 形 式 为 : fwrite(buffer,size,count,fp); 其 中 buffer 是 一 个 指 针, 在 fread 函 数 中, 它 表 示 存 放 输 入 数 据 的 首 地 址 在 fwrite 函 数 中, 它 表 示 存 放 输 出 数 据 的 首 地 址 size 表 示 数 据 块 的 字 节 数 count 表 示 要 读 写 的 数 据 块 块 数 fp 表 示 文 件 指 针 例 如 : 输 入 若 干 学 生 成 绩 将 成 绩 写 入 文 件 中 void save( ) FILE *fp; int i; if((fp=fopen("stu-list","wb"))==null) printf("cannot open file\n"); return; for(i=0;i<size;i++)/* 二 进 制 写 */ if(fwrite(&stud[i],sizeof(struct student_type),1,fp)!=1) printf( file write error\n );/* 出 错 处 理 */ fclose(fp); /* 关 闭 文 件 */ int i; for(i=0;i<size;i++)/* 从 键 盘 读 入 学 生 信 息 */ 126

127 scanf("%s%d%d%s",stud[i].name,&stud[i].num, &stud[i].age,stud[i].addr); save( );/* 调 用 save() 保 存 学 生 信 息 */ 格 式 化 写 fprintf 函 数 为 格 式 化 写 函 数, 与 前 面 使 用 的 printf 函 数 的 区 别 在 于 fprintf 函 数 的 写 对 象 是 磁 盘 文 件 这 个 函 数 的 调 用 格 式 为 : fprintf( 文 件 指 针, 格 式 字 符 串, 输 出 表 列 ); 注 意 : 用 fprintf 和 fscanf 函 数 对 磁 盘 文 件 读 写, 使 用 方 便, 容 易 理 解, 但 由 于 在 输 入 时 要 将 ASCII 码 转 换 为 二 进 制 形 式, 在 输 出 时 又 要 将 二 进 制 形 式 转 换 成 字 符, 花 费 时 间 比 较 多 因 此, 在 内 存 与 磁 盘 频 繁 交 换 数 据 的 情 况 下, 最 好 不 用 fprintf 和 fscanf 函 数, 而 用 fread 和 fwrite 函 数 例 如 :fprintf() 将 格 式 化 输 出 写 入 到 文 件 和 stdout 中 #include <stdio.h> #include <stdlib.h> void clear_kb(void); int main(void) FILE *fp; float data[5]; int count; char filename[20]; puts("enter 5 floating point numerical values."); for(count = 0; count < 5; count++) scanf("%f", &data[count]); clear_kb(); puts("enter a name for the file."); gets(filename); if((fp = fopen(filename, "w")) == NULL) fprintf(stderr, "Error opening file %s.", filename); exit(1); for(count = 0; count < 5; count++) fprintf(fp, "\ndata[%d] = %f", count, data[count]); fprintf(stdout, "\ndata[%d] = %f", count, data[count]); fclose(fp); printf("\n"); return 0; 127

128 void clear_kb(void) char junk[80]; gets(junk); 5.4 典 型 案 例 分 析 1. 以 下 程 序 企 图 把 从 终 端 输 入 的 字 符 输 出 到 名 为 abc.txt 的 文 件 中, 直 到 从 终 端 读 入 字 符 # 号 时 结 束 输 入 和 输 出 操 作, 但 程 序 有 错 #include<stdio.h> FILE*fout;char ch; fout=fopen('abc.txt','w'); ch=fgetc(stdin); while(ch!='#') fputc(ch,fout); ch=fgetc(stdin); 出 错 的 原 因 是 A 函 数 fopen() 调 用 形 式 错 误 B 输 入 文 件 没 有 关 闭 C 函 数 fgetc() 调 用 形 式 错 误 D 文 件 指 针 stdin 没 有 定 义 分 析 本 题 没 有 什 么 复 杂 的 算 法, 主 要 考 查 基 本 语 法, 本 题 函 数 fopen() 调 用 形 式 有 错 误 因 此 本 题 的 正 确 答 案 为 A 2. 以 下 程 序 用 来 统 计 文 件 中 字 符 的 个 数, 请 填 空 #include<stdio.h> FILE *fp; long num=0; If((fp=fopen("fname.dat", ))= =NULL) print("open error \n");exit(0); while ; num++; printf("num=%ld\n",--num); fclose(fp); 128

129 分 析 按 题 目 要 求, 程 序 要 从 文 件 中 输 入 字 符, 因 此 在 第 一 个 空 出 应 填 r" 程 序 使 文 件 指 针 fp 指 向 输 入 文 件, 因 此 在 while 后 面 应 填 (! feof(fp)) 从 文 件 中 输 入 字 符 应 该 调 用 fgetc() 函 数, 因 为 只 是 统 计 文 件 中 字 符 的 个 数, 而 没 有 对 输 入 的 字 符 进 行 处 理, 所 以 在 第 三 个 空 处 应 填 fgetc(fp) 因 此 本 题 的 正 确 答 案 为 "r" (! feof(fp)) fgetc(fp) 3. 有 以 下 程 序 : #include<stdio.h> FILE *fp;int i=20,j=50,k,n; fp=fopen("d1.dat","w"); fprintf(fp,"%d\n",i);fprintf(fp,"%d\n",j); fclose(fp); fp=fopen("d1.dat","r"); fscanf(fp,"%d%d",&k,&n);printf("%d%d\n",k,n); fclose(fp); 程 序 运 行 后 的 输 出 结 果 是 A B C D 分 析 本 题 首 先 通 过 函 数 fprintf() 将 变 量 i,j 的 值 输 出 到 已 打 开 的 d1.dat 文 件 中, 再 由 函 数 fscanf() 从 d1.dat 中 读 取 i,j 的 值 到 k,n 因 此 本 题 的 正 确 答 案 为 B 4. 下 列 程 序 的 输 出 结 果 是 #include<stdio.h> 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); A 12 B 1230 C123 D 00 分 析 在 文 件 写 操 作 时, 两 个 数 之 间 应 用 空 格 隔 开, 而 在 本 题 中, 没 有 用 空 格 隔 开, 所 以 123 视 为 一 个 数 因 此 本 题 的 正 确 答 案 为 B 5. 已 有 文 本 文 件 test.txt", 其 中 的 内 容 为 :Hello,everyone! 以 下 程 序 中, 文 件 test.txt 已 正 确 为 读 " 而 打 开, 由 文 件 指 针 fr 指 向 该 文 件, 则 程 序 的 输 出 结 果 是 #include <stdio.h> FILE *fr;char str[40]; 129

130 fgets(str,5,fr); printf("%s\n",str); fclose(fr); 分 析 函 数 fgets(str,5,fr) 的 功 能 是 从 fr 所 指 的 文 件 中 读 入 4 个 字 符 并 存 入 str 所 指 的 存 储 空 间 内 因 此 本 题 的 正 确 答 案 为 Hell 6. 有 以 下 程 序 ( 提 示 : 程 序 中 fseek(fp,-2l sizeof(int), SEEK_END);" 语 句 的 作 用 是 使 位 置 指 针 从 文 件 末 尾 向 前 移 2*sizeof(int) 字 节 ) #include<stdio.h> FILE *fp;int i,a[4]=1,2,3,4,b fp=fopen("data.dat","wb"); for(i=0;i<4;i++)fwrite(&a[i],sizeof(int),1,fp); fclose(fp) fp=fopen("data.dat","rb"); fseek(fp,-2l*sizeof(int),seek_end); fread(&b,sizeof(int),1,fp);/* 从 文 件 中 读 取 sizeof(int) 字 节 的 数 据 到 变 量 b*/ fclose(fp); printf("%d\n",b); 执 行 后 输 出 结 果 是 A 2 B 1 C 4 D 3 分 析 本 题 主 要 考 查 输 入 输 出 函 数 的 作 用 open() 函 数 的 作 用 是 以 指 定 的 方 式 打 开 指 定 的 文 件,fread() 函 数 的 作 用 是 从 指 定 的 文 件 中 按 指 定 的 格 式 把 输 入 数 据 存 入 指 定 的 变 量 中, fwrite() 函 数 的 作 用 是 把 指 定 个 数 的 字 节 输 出 到 指 定 文 件 中 因 此 本 题 的 正 确 答 案 为 D 7. 程 序 设 计 : 读 入 文 件 e10-1.c, 在 屏 幕 上 输 出 #include<stdio.h> FILE *fp; char ch; if((fp=fopen("e10_1.c","rt"))==null) printf("cannot open file strike any key exit!"); getch(); exit(1); ch=fgetc(fp); while (ch!=eof) putchar(ch); ch=fgetc(fp); 130

131 fclose(fp); 分 析 本 例 程 序 的 功 能 是 从 文 件 中 逐 个 读 取 字 符, 在 屏 幕 上 显 示 程 序 定 义 了 文 件 指 针 fp, 以 读 文 本 文 件 方 式 打 开 文 件 e10_1.c", 并 使 fp 指 向 该 文 件 如 打 开 文 件 出 错, 给 出 提 示 并 退 出 程 序 程 序 第 12 行 先 读 出 一 个 字 符, 然 后 进 入 循 环, 只 要 读 出 的 字 符 不 是 文 件 结 束 标 志 ( 每 个 文 件 末 有 一 结 束 标 志 EOF) 就 把 该 字 符 显 示 在 屏 幕 上, 再 读 入 下 一 字 符 每 读 一 次, 文 件 内 部 的 位 置 指 针 向 后 移 动 一 个 字 符, 文 件 结 束 时, 该 指 针 指 向 EOF 执 行 本 程 序 将 显 示 整 个 文 件 8. 程 序 设 计 : 把 命 令 行 参 数 中 的 前 一 个 文 件 名 标 识 的 文 件, 复 制 到 后 一 个 文 件 名 标 识 的 文 件 中, 如 命 令 行 中 只 有 一 个 文 件 名 则 把 该 文 件 写 到 标 准 输 出 文 件 ( 显 示 器 ) 中 #include<stdio.h> main(int argc,char *argv[]) FILE *fp1,*fp2; char ch; if(argc==1) printf("have not enter file name strike any key exit"); getch(); exit(0); if((fp1=fopen(argv[1],"rt"))==null) printf("cannot open %s\n",argv[1]); getch(); exit(1); if(argc==2) fp2=stdout; else if((fp2=fopen(argv[2],"wt+"))==null) printf("cannot open %s\n",argv[1]); getch(); exit(1); while((ch=fgetc(fp1))!=eof) fputc(ch,fp2); fclose(fp1); fclose(fp2); 分 析 本 程 序 为 带 参 的 main 函 数 程 序 中 定 义 了 两 个 文 件 指 针 fp1 和 fp2, 分 别 指 向 命 令 行 参 数 中 给 出 的 文 件 如 命 令 行 参 数 中 没 有 给 出 文 件 名, 则 给 出 提 示 信 息 程 序 第 18 行 表 示 如 果 只 给 出 一 个 文 件 名, 则 使 fp2 指 向 标 准 输 出 文 件 ( 即 显 示 器 ) 程 序 第 25 行 至 28 行 用 循 环 语 句 逐 个 读 出 文 件 1 中 的 字 符 再 送 到 文 件 2 中 再 次 运 行 时, 给 出 了 一 个 文 件 名, 所 建 立 的 文 件 ), 故 输 出 给 标 准 输 出 文 件 stdout, 即 在 显 示 器 上 显 示 文 件 内 容 第 三 次 运 行, 131

132 给 出 了 二 个 文 件 名, 因 此 把 string 中 的 内 容 读 出, 写 入 到 OK 之 中 9. 程 序 设 计 : 从 e10_1.c 文 件 中 读 入 一 个 含 10 个 字 符 的 字 符 串 #include<stdio.h> FILE *fp; char str[11]; if((fp=fopen("e10_1.c","rt"))==null) printf("cannot open file strike any key exit!"); getch(); exit(1); fgets(str,11,fp); printf("%s",str); fclose(fp); 分 析 本 例 定 义 了 一 个 字 符 数 组 str 共 11 个 字 节, 在 以 读 文 本 文 件 方 式 打 开 文 件 e101.c 后, 从 中 读 出 10 个 字 符 送 入 str 数 组, 在 数 组 最 后 一 个 单 元 内 将 加 上 '\0', 然 后 在 屏 幕 上 显 示 输 出 str 数 组 10 程 序 设 计 : 从 键 盘 输 入 两 个 学 生 数 据, 写 入 一 个 文 件 中, 再 读 出 这 两 个 学 生 的 数 据 显 示 在 屏 幕 上 #include<stdio.h> struct stu char name[10]; int num; int age; char addr[15]; boya[2],boyb[2],*pp,*qq; FILE *fp; char ch; int i; pp=boya; qq=boyb; if((fp=fopen("stu_list","wb+"))==null) printf("cannot open file strike any key exit!"); getch(); exit(1); printf("\ninput data\n"); 132

133 for(i=0;i<2;i++,pp++) scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr); pp=boya; fwrite(pp,sizeof(struct stu),2,fp); rewind(fp); fread(qq,sizeof(struct stu),2,fp); printf("\n\nname\tnumber age addr\n"); for(i=0;i<2;i++,qq++) printf("%s\t%5d%7d%s\n",qq->name,qq->num,qq->age,qq->addr); fclose(fp); 分 析 本 例 程 序 定 义 了 一 个 结 构 stu, 说 明 了 两 个 结 构 数 组 boya 和 boyb 以 及 两 个 结 构 指 针 变 量 pp 和 qq pp 指 向 boya,qq 指 向 boyb 程 序 第 16 行 以 读 写 方 式 打 开 二 进 制 文 件 stu_list", 输 入 二 个 学 生 数 据 之 后, 写 入 该 文 件 中, 然 后 把 文 件 内 部 位 置 指 针 移 到 文 件 首, 读 出 两 块 学 生 数 据 后, 在 屏 幕 上 显 示 练 一 练 一 单 选 题 1 文 件 的 指 针 用 来 A 标 识 文 件 在 内 存 中 的 存 放 地 址 B 标 识 文 件 在 外 部 介 质 中 的 存 放 地 址 C 标 识 文 件 中 读 写 位 置 D 指 向 某 个 文 件 的 信 息 区 2 在 缓 冲 文 件 系 统 中, 缓 冲 区 的 大 小 一 般 A 1024B B 512B C 由 程 序 员 决 定 D 根 据 文 件 大 小 确 定 3 在 进 行 文 件 操 作 前, 首 先 要 打 开 文 件, 打 开 文 件 的 目 的 是 A 将 磁 盘 文 件 中 的 内 容 全 部 复 制 到 B 在 程 序 与 磁 盘 之 间 建 立 一 个 专 用 传 输 通 道 C 建 立 程 序 与 文 件 缓 冲 区 之 间 的 联 系 D 建 立 文 件 与 程 序 之 间 的 联 系 4 使 用 fopen() 函 数 打 开 文 件 时, 读 写 指 针 A 一 定 在 文 件 首 B 一 定 在 文 件 尾 C 在 文 件 的 任 意 位 置 D 以 上 均 可 二 填 空 题 (4 分 ) 1 如 果 调 用 fclose() 函 数 不 成 功, 则 函 数 返 回 值 2 设 有 结 构 体 类 型 : struct stud char name[8]; Int num; float s[4]; student[80]; 结 构 体 数 组 student 中 的 元 素 都 已 赋 值, 若 将 数 组 元 素 写 到 数 据 文 件 中, 其 fwrite 函 数 的 调 用 是 fwrite(student,,1,fp) 3 若 要 打 开 D 盘 user 子 目 录 下 名 为 abc.txt 的 文 本 文 件 进 行 读 写 操 作, 请 写 出 符 合 上 述 133

134 要 求 的 函 数 调 用 语 句 三 程 序 调 试 题 ( 下 列 各 程 序 中 存 在 一 些 问 题, 通 过 调 试 发 现 问 题, 并 加 以 修 正, 使 其 实 现 预 期 目 标 ) 1 下 列 程 序 的 功 能 为 : 在 键 盘 输 入 四 行 字 符 写 到 D 盘 data1.dat 文 件 中, 请 纠 正 程 序 中 存 在 错 误, 使 程 序 实 现 其 功 能 程 序 3.1 #include <stdio.h> #include<string.h> void FILE *fp1; char ch[80]; int i,j; fp1=fopen("d:\\data1.dat","b"); for(i=1;i<=4;i++) gets(ch); j=0; while(ch[j]!='\0') fputc(fp1, ch[j]); j++; fputc(fp1,'\n'); fclose(fp1); 2 下 列 程 序 的 功 能 为 : 随 机 产 生 10 整 数, 写 入 一 个 二 进 制 文 件 中, 请 纠 正 程 序 中 存 在 错 误, 使 程 序 实 现 其 功 能 程 序 3.2 #include <stdlib.h> #include <stdio.h> #include <time.h> void main ( ) int x[10],i,k; FILE *fp2; srand( (unsigned)time( NULL ) ); for (i=0;i<10;i++) x[i]=rand(); fp2=fopen ("d:\\data2.dat","wb"); if(fp2==null) printf("open error \n");exit(0); for (int k=0 ; k<10 ; k++ ) 134

135 fwrite( x[k],sizeof(int), fp2); fclose (fp2 ) ; 3 下 列 程 序 的 功 能 为 : 从 数 组 读 入 数 据, 建 立 ASCII 码 文 件, 并 按 下 列 格 式 输 出 : ( 每 个 数 据 占 5 个 字 符 宽 度 ), 请 纠 正 程 序 中 存 在 语 法 错 误, 使 程 序 实 现 其 功 能 程 序 3.3 #include<stdio.h> #include<stdlib.h> void FILE *fp3; int b[]=10,20,30,40,50,60,70,80,90,100,i=0,n; if((fp3=fopen("e:\\file9_3.txt","w"))==null) printf("%s 不 能 打 开 \n","e:\\file9_3.txt"); exit(1); while(i<10) fprintf(fp3,"%d",b[i]); if(i%3==0) fprintf(fp3,"\n"); i++; fclose(fp3); if((fp3=fopen("e:\\file9_3.txt","r"))==null) printf("%s 不 能 打 开 读 \n","e:\\file9_3.txt"); exit(1); fscanf(fp3,"%5d",&n); while(!feof(fp3)) printf("%5d",n); fscanf(fp3,"%d",&n); printf("\n"); fclose(fp3); 四 程 序 填 空 题 ( 请 填 写 适 当 的 符 号, 使 程 序 实 现 其 功 能 ) 1 下 列 程 序 的 功 能 为 : 从 字 符 指 针 数 组 读 出 字 符 串, 建 立 ASCII 码 文 件 file9_4.txt, 请 填 写 适 当 的 符 号 或 语 句, 使 程 序 实 现 其 功 能 程 序 4.1 #include<stdio.h> #include<stdlib.h> void FILE *fp; int i=0; 135

136 char *str[]="visual C++","visual Basic","visual java","visual foxpro"; if((fp=fopen("e:\\file9_4.txt", ))==NULL) printf("%s 不 能 打 开!\n","file9_4.txt"); exit(1); while(i<4) fprintf( ); ; fclose(fp); 2 下 列 程 序 的 功 能 为 : 用 来 统 计 D 盘 fname.dat 文 件 中 字 符 的 个 数, 请 填 写 适 当 的 符 号 或 语 句, 使 程 序 实 现 其 功 能 程 序 4.2 #include<stdio.h> #include<stdlib.h> void char c; FILE *fp3; long num=0; if((fp3=fopen("d:\\fname.dat", ))==NULL) printf("open error \n");exit(0); c=fgetc(fp3); while ( ) ; c=fgetc(fp3); printf("\nnum=%ld\n", num); ; 3 下 列 程 序 的 功 能 为 : 从 字 符 指 针 数 组 读 出 字 符 串, 建 立 和 输 出 二 进 制 文 件 file9_6.dat, 请 填 写 适 当 的 符 号 或 语 句, 使 程 序 实 现 其 功 能 程 序 4.3 #include<stdio.h> #include<stdlib.h> #include<string.h> void FILE *fp6; int i=0; char str[][20]="visual C++","visual Basic","visual java","visual foxpro"; 136

137 char s[20]; if((fp6=fopen("e:\\file9_6.dat", )==NULL) printf("%s 不 能 打 开!\n","file9_6.dat"); exit(1); while(i<4) fwrite(,,1,fp6); i++; fclose(fp6); if((fp6=fopen("e:\\file9_6.dat", ))==NULL) printf("%s 不 能 打 开!\n","file9_6.dat"); exit(1); fread((,,1,fp6); while(!feof(fp6)) printf("%s\n",s); fread((,,1,fp6); fclose(fp6); 五 编 程 1 编 写 一 个 程 序 实 现 如 下 功 能 : 有 5 个 学 生, 每 个 学 生 有 3 门 课 的 成 绩, 从 键 盘 输 入 以 上 数 据 ( 包 括 学 生 号, 姓 名, 三 门 课 成 绩 ), 计 算 出 平 均 成 绩, 将 原 有 数 据 和 计 算 出 的 平 均 分 数 存 放 在 磁 盘 文 件 stud 中 2 编 写 一 个 程 序 实 现 如 下 功 能 : 将 一 个 整 形 ASCII 码 文 件 FileA.txt 复 制 到 ASCII 码 文 件 FileB.txt FileA.txt FileB.txt 编 写 一 个 程 序 实 现 如 下 功 能 : 有 一 个 整 数 文 件 ( 二 进 制 文 件 ), 读 取 其 中 的 数 值, 如 果 为 奇 数 加 一 ; 如 果 为 偶 数, 减 一, 存 放 到 新 的 文 件 中 去 137

138 第 6 章 应 试 指 南 6.1 概 念 题 分 析 1. 以 下 C 程 序 中 预 处 理 命 令 写 法 正 确 的 是 : A. #include (stdio.h) B. #include [stdio.h] C. #include stdio.h D. #include <stdio.h> 知 识 点 : 预 处 理 命 令 的 书 写 格 式, 预 处 理 命 令 都 以 "#" 开 头, 称 为 宏 定 义 命 令, 常 用 预 处 理 命 令 有 两 条, 即 : 文 件 包 含 预 处 理 命 令, 其 作 用 是 使 一 个 源 文 件 将 另 一 个 源 文 件 的 全 部 内 容 包 含 进 来, 其 一 般 形 式 为 : # include < 文 件 名.h> 或 # include 文 件 名.h 说 明 : (1) 文 件 名 应 是 C 语 言 的 源 文 件 名 该 源 文 件 可 以 是 系 统 提 供 的, 也 可 以 是 用 户 编 写 的 通 常 称 为 头 文 件, 习 惯 用 字 母 h 作 为 后 缀 如 : # include <stdio.h> 或 # include stdio.h (2) 两 种 形 式 的 区 别 : 当 文 件 名 用 尖 括 号 括 起 来 时, 系 统 到 存 放 C 库 函 数 头 文 件 所 在 的 目 录 中 寻 找 要 包 含 的 文 件, 这 称 为 标 准 方 式 ; 而 文 件 名 用 双 引 号 括 起 来 时, 系 统 先 在 用 户 当 前 目 录 中 寻 找 要 包 含 的 文 件, 如 果 找 不 到, 再 按 标 准 方 式 查 找 (3) 一 个 include 命 令 只 能 指 定 一 个 被 包 含 的 文 件 定 义 符 号 常 量 预 处 理 命 令, 其 作 用 是 该 标 识 符 定 义 为 其 后 的 常 量 值 一 经 定 义, 以 后 在 程 序 中 所 有 出 现 该 标 识 符 的 地 方 均 代 之 以 该 常 量 值 如 # define M 10, 在 编 译 预 处 理 时, 凡 遇 到 标 识 符 (M), 就 替 换 为 指 定 字 符 串 (10), 这 称 为 宏 展 开, 然 后 才 开 始 编 译 其 一 般 形 式 为 : #define 标 识 符 常 量 说 明 : (1) 习 惯 上 符 号 常 量 的 标 识 符 用 大 写 字 母, 变 量 标 识 符 用 小 写 字 母, 以 示 区 别 (2) 符 号 常 量 必 须 先 定 义 后 使 用 分 析 : 本 题 考 核 的 是 文 件 包 含 预 处 理 命 令, 由 文 件 包 含 预 处 理 命 令 的 一 般 形 式 可 以 判 断 出 #include <stdio.h> 是 正 确 的 预 处 理 命 令 的 书 写 格 式 答 案 : D 2. 设 有 变 量 定 义 语 句 char a; 则 下 面 的 赋 值 语 句 中 是 正 确 的 A. a='&'; B. a="&"; C. a=' ' '; D. a='16' ; 知 识 点 : 字 符 型 数 据 的 取 值, 变 量 a 是 字 符 型 变 量, 它 的 值 应 为 字 符 常 量 或 另 一 个 字 符 型 变 量,C 语 言 的 字 符 常 量 为 ASCII 码 字 符 集 中 的 一 个 字 符, 在 程 序 中 用 单 引 号 括 起 来 如 138

139 字 符 常 量 A 在 程 序 中 要 用 'A' 表 示 C 语 言 规 定 : 字 符 常 量 可 以 作 为 整 型 常 量 来 处 理, 因 为 在 计 算 机 内 部, 一 个 字 符 型 数 据 所 对 应 的 整 数 值 就 是 该 字 符 所 对 应 的 ASCII 码 值, 因 此 字 符 常 量 可 以 参 与 算 术 运 算 字 符 型 数 据 在 内 存 中 以 ASCII 码 存 储, 故 整 型 数 据 和 字 符 型 数 据 在 一 定 范 围 内 可 以 通 用 字 符 常 量 可 以 是 转 义 符 分 析 : 本 题 提 供 的 选 项 中 出 现 的 均 是 字 符 常 量, 按 字 符 常 量 在 程 序 中 的 表 示 方 式 可 知, 选 项 B 和 D 是 错 误 的, 而 字 符 常 量 单 引 号 在 程 序 中 以 转 义 符 号 的 形 式 出 现 的 ( 由 于 单 引 号 作 为 字 符 常 量 的 定 界 符, 为 了 避 免 二 义 性 ), 因 此, 选 项 C 是 错 误 的 答 案 : A 3. 设 有 char ch; 与 语 句 ch=getchar(); 等 价 的 语 句 是 : A. printf("%c",ch); B. printf("%c",&ch); C. scanf("%c",ch); D. scanf("%c",&ch); 知 识 点 : 输 入 函 数 的 应 用,getchar() 的 功 能 是 从 键 盘 上 输 入 一 个 字 符, 语 句 ch=getchar(); 则 将 所 输 入 的 字 符 赋 予 变 量 ch 字 符 的 键 盘 输 入 除 使 用 getchar() 外, 还 可 以 使 用 scanf() 函 数, scanf () 函 数 的 作 用 是 把 从 终 端 ( 如 键 盘 ) 上 输 入 的 数 据 传 送 给 对 应 的 变 量 scanf () 函 数 的 一 般 格 式 为 : scanf ( 格 式 控 制, 输 入 项 地 址 表 ) 而 格 式 控 制 符 号 "%c" 的 功 能 是 输 入 单 个 字 符 分 析 : 由 知 识 点 可 知 getchar() 与 scanf ("%c", 输 入 项 地 址 表 ) 的 功 能 相 同, 因 此, 在 选 项 C 和 D 中 选 择 答 案, 而 选 项 C 的 第 2 个 参 数 错 误, 按 scanf() 格 式 第 2 个 参 数 是 输 入 项 地 址, 本 题 中 的 输 入 项 是 ch, 而 输 入 项 地 址 则 是 &ch 正 确 选 项 自 然 是 D 答 案 : D 4. int a=2, b=5; 则 表 达 式 21%9/(float)a+4/b*b 的 运 算 结 果 为 A. 2 B. 1 C. 1.5 D. 0 知 识 点 : 数 据 类 型 转 换 算 术 运 算 和 变 量 初 始 化 在 算 术 表 达 式 中 数 据 类 型 转 换 具 有 自 动 类 型 转 换 也 称 为 隐 式 类 型 转 换 C 语 言 约 定 自 动 转 换 规 则 是 由 低 级 向 高 级 转 换, 如 果 一 个 运 算 符 带 有 两 个 不 同 类 型 的 操 作 数, 那 么 在 操 作 之 前 先 将 较 低 的 类 型 转 换 为 较 高 的 类 型, 然 后 进 行 运 算, 运 算 结 果 取 较 高 的 类 型 强 制 类 型 转 换 又 称 为 显 式 类 型 转 换, 是 根 据 程 序 的 需 要, 将 某 数 据 强 制 转 换 成 指 定 的 数 据 类 型 其 方 法 是 在 被 转 换 对 象 ( 或 表 达 式 ) 前 面 增 加 类 型 标 识 符, 形 式 如 下 : ( 类 型 标 识 符 ) 表 达 式 程 序 中, 一 个 变 量 占 据 着 一 个 实 际 的 存 储 单 元, 变 量 名 实 际 上 是 存 储 单 元 的 标 志 ( 逻 辑 地 址 ), 存 储 单 元 中 的 内 容 才 是 变 量 的 值 C 允 许 在 定 义 变 量 的 同 时 对 其 赋 初 值 分 析 :int a=2, b=5; 则 完 成 了 对 变 量 a, b 的 定 义 同 时 对 其 赋 初 值 本 题 按 算 术 运 算 先 计 算 21%9, 结 果 为 3, 计 算 3/2.0, 结 果 为 1.5, 计 算 4/5, 结 果 为 0,0*5, 结 果 为 0, 最 后 计 算 1.5+0, 结 果 为 1.5 答 案 : C 5. 能 正 确 表 示 逻 辑 关 系 "a>=10 或 a<=0" 的 C 语 言 表 达 式 是 A. a>=10 or a<=0 B. a<=0 a>=10 139

140 C. a<=0 a>=10 D. a>=10 && a<=0 知 识 点 : 关 系 逻 辑 表 达 式, 逻 辑 运 算 是 用 来 连 接 关 系 运 算, 逻 辑 运 算 符 两 端 的 操 作 数 如 为 非 0, 就 当 作 真 来 处 理, 如 果 是 0, 便 当 作 假 来 处 理 逻 辑 运 算 的 结 果 也 只 有 0(false) 和 1(true) 两 种 C 语 言 提 供 3 种 逻 辑 运 算 符 :&&( 逻 辑 与 ), ( 逻 辑 或 ),!( 逻 辑 非 ) 分 析 : 根 据 逻 辑 运 算 符 和 本 题 的 题 面, 用 ( 逻 辑 或 ) 连 接 a>=10 和 a<=0, 即 : a<=0 a>=10 答 案 : C 6. 设 有 int n=60; 写 出 下 列 语 句 的 运 行 结 果 switch (n/10) case 6: printf("@");break; case 5: printf("#"); default: printf("$"); B. #$ C. $ 知 识 点 :switch 的 语 义, switch 语 句 的 执 行 过 程 为 : 先 计 算 表 达 式 的 值, 然 后 将 它 与 语 句 体 内 各 case 后 的 常 量 表 达 式 的 值 相 比 较, 若 有 与 该 值 相 等 者, 则 执 行 该 case 后 的 语 句 ; 若 无 与 该 值 相 等 者, 则 执 行 default 子 句 中 的 语 句 break 语 句 将 使 流 程 控 制 跳 出 整 个 switch 语 句 若 不 写 break 语 句, 在 执 行 完 一 个 case 后 面 的 语 句 后, 流 程 控 制 将 转 移 到 下 一 个 case, 继 续 执 行 其 后 面 的 语 句, 如 此 继 续, 直 至 最 后 分 析 : 本 题 表 达 式 n/10 的 值 为 6, 执 行 case 6: printf("@");break; 后 退 出 switch 体, 因 此, 输 答 案 : D 7. 设 有 int i; 以 下 语 句 中, 循 环 次 数 为 100 次 的 语 句 是 : A. for ( i=0; i<=100; i++ ) B. for ( i=0; i<99; i++ ) C. for ( i=1; i<99; i++ ) D. for ( i=0; i<100; i++ ) 知 识 点 :for 语 句 的 循 环 次 数,for 语 句 的 一 般 形 式 为 : for ( 表 达 式 1; 表 达 式 2; 表 达 式 3) 语 句 ; 其 中 : 表 达 式 1 用 于 给 循 环 变 量 赋 初 值 ; 表 达 式 2 给 出 执 行 循 环 体 的 条 件 ; 表 达 式 3 用 于 修 改 循 环 变 量 循 环 次 数 的 计 算 公 式 :( 终 值 - 初 值 +1)/ 步 长 分 析 : 按 循 环 次 数 的 计 算 公 式 对 选 项 A 进 行 运 算,( )/1=101; 对 选 项 B 进 行 运 算, (98-0+1)/1=99; 对 选 项 C 进 行 运 算,(98-1+1)/1=98; 对 选 项 D 进 行 运 算,(99-0+1)/1=100 答 案 : D 8. C 程 序 中, 用 于 提 前 结 束 本 次 循 环 进 行 下 一 次 循 环 的 语 句 是 A. break B. continue 140

141 C. return D. exit 知 识 点 : 在 循 环 体 内 使 用 continue 语 句 和 break 语 句,continue 语 句 结 束 本 轮 循 环, 即 跳 过 循 环 中 尚 未 执 行 的 语 句, 返 回 到 循 环 的 开 始 处 在 while 和 do-while 循 环 中,continue 语 句 将 使 控 制 直 接 转 向 条 件 测 试 部 分, 从 而 决 定 是 否 继 续 执 行 循 环 在 for 循 环 中, 遇 到 continue 语 句 后, 首 先 计 算 for 语 句 中 表 达 式 3 的 值, 然 后 再 执 行 条 件 测 试 ( 表 达 式 2), 最 后 根 据 测 试 结 果 来 决 定 是 否 继 续 执 行 for 循 环 continue 语 句 的 一 般 形 式 为 : continue; break 语 句 的 一 般 形 式 为 : break; break 语 句 有 两 个 用 途 : (1) 在 switch 语 句 中 用 来 使 流 程 跳 出 switch 结 构, 继 续 执 行 switch 语 句 后 面 的 语 句 (2) 用 在 循 环 体 内, 迫 使 所 在 循 环 立 即 终 止, 即 跳 出 所 在 循 环, 继 续 执 行 循 环 体 后 面 的 语 句 continue 语 句 仅 仅 结 束 本 轮 循 环, 而 不 终 止 整 个 循 环 的 执 行 break 语 句 则 是 结 束 所 在 循 环, 跳 出 所 在 循 环 在 多 重 循 环 结 构 中, 一 个 break 语 句 只 能 从 它 自 身 所 在 循 环 体 的 那 个 循 环 结 构 跳 出, 亦 即 它 只 能 实 现 向 外 跳 一 层 分 析 : 按 continue 语 句 的 语 义 可 知, 该 语 句 满 足 本 题 要 求 答 案 : B 9. 若 有 数 组 定 义 语 句 :int t[3][2]; 则 t 数 组 最 后 一 个 元 素 是 : A. t[3][2] B. t[2][3] C. t[2] D. t[2][1] 知 识 点 : 二 维 数 组 定 义 的 一 般 形 式 为 : 类 型 说 明 符 数 组 名 [ 常 量 表 达 式 1][ 常 量 表 达 式 2]; 其 中 常 量 表 达 式 1 表 示 第 一 维 下 标 的 长 度, 常 量 表 达 式 2 表 示 第 二 维 下 标 的 长 度 例 如 : int a[3][2]; 说 明 了 一 个 3 行 2 列 的 数 组, 数 组 名 为 a, 其 下 标 变 量 的 类 型 为 整 型 该 数 组 的 下 标 变 量 共 有 3 2 个, 即 : a[0][0],a[0][1] a[1][0],a[1][1] a[2][0],a[2][1] 分 析 : 根 据 二 维 数 组 定 义 可 知,t 数 组 最 后 一 个 元 素 是 t[2][1] 答 案 : D 10. 设 有 定 义 int a[]=1,3,5,7,9,*p=a; while(*p!=3) p++; 结 果 为 7 的 表 达 式 是 : A. *(p+2) B. *(p+3) C. *p+2 D. *p+3 知 识 点 : 一 维 数 组 初 始 化 定 义 数 组 时 对 数 组 元 素 赋 以 初 值 例 如 : 141

142 int a[10]= 0,1,2,3,4,5,6,7,8,9 ; 经 过 上 面 的 定 义 和 初 始 化 之 后, 相 当 于 a[0]=0,a[1]=1,a[2]=2,a[3]=3,a[4]=4, a[5]=5,a[6]=6,a[7]=7,a[8]=8,a[9]=9 注 意 : 1 只 给 部 分 元 素 赋 初 值 即 当 中 值 的 个 数 少 于 元 素 个 数 时, 只 给 前 面 部 分 元 素 赋 值, 没 有 赋 值 的 元 素 系 统 根 据 元 素 的 数 据 类 型 按 数 值 型 元 素 赋 0, 字 符 型 元 素 赋 \0 原 则 进 行 处 理 2 如 给 全 部 元 素 赋 值, 则 在 数 组 说 明 中, 可 以 不 给 出 数 组 元 素 的 个 数 例 如 : int a[5]=1,3,5,7,9; 可 写 为 :int a[]=1,3,5,7,9; 数 组 是 连 续 数 据 单 元 的 序 列, 数 组 元 素 内 存 地 址 的 偏 移 量 一 定 是 相 同 的, 相 邻 元 素 间 地 址 的 差 值 就 是 数 组 元 素 占 用 的 字 节 数 数 组 名 是 一 个 地 址 常 量, 表 示 数 组 的 首 地 址 值, 是 一 个 指 针 常 量 a [i] 来 表 示 某 个 数 组 元 素 则 是 用 下 标 法 表 示 的, 也 可 以 利 用 *( 数 组 名 称 +i) 的 方 式 引 用 该 元 素, 而 数 组 名 称 +i 就 是 该 元 素 的 首 地 址 将 数 组 看 成 指 针 来 使 用 或 者 将 一 个 指 针 变 量 指 向 该 数 组, 用 指 针 变 量 来 引 用 数 组 元 素, 则 是 指 针 表 示 法 如 :int a [6];int *p; p=a; 首 先 要 对 指 针 进 行 初 始 化, 将 数 组 的 首 地 址 赋 值 给 指 针 变 量 p 当 i 是 整 型 值 时, 用 p+i 表 示 a [i] 的 地 址, 即 & a [i] 而 *(p+i) 表 示 元 素 a [i] 的 值 对 于 指 针 变 量 p 可 进 行 p++,p--,++p,--p 等 运 算 分 析 : 执 行 while(*p!=3) p++; 后 指 针 指 向 a [1],(p+2) 则 指 向 a [3], 而 用 指 针 法 表 示 数 组 元 素 a [3] 的 则 是 *(p+2) 答 案 : A 11. char a[10]; 不 能 将 字 符 串 "abc" 存 储 在 数 组 a 中 的 是 A. strcpy(a,"abc"); B. a[0]=0;strcat(a,"abc"); C. a="abc"; D. int i; for(i=0;i<3;i++)a[i]=i+97;a[i]=0; 知 识 点 : 在 C 语 言 中, 由 于 没 有 专 门 的 字 符 串 变 量, 而 字 符 串 在 编 程 中 又 是 很 重 要 的 一 个 特 性 为 了 能 够 灵 活 体 现 字 符 串 的 特 性,C 语 言 规 定 使 用 字 符 型 数 组 来 存 储 和 处 理 字 符 串 但 有 特 殊 要 求, 那 就 是, 一 个 字 符 串 必 须 以 空 字 符 '\0' 作 为 其 结 束 标 志 如 果 一 个 字 符 型 数 组 中 所 存 储 的 一 系 列 字 符 后 跟 随 有 空 字 符 '\0', 那 么 就 可 以 说 明 该 字 符 数 组 中 存 储 了 一 个 字 符 串 如 :char str[ ]= 'b','o','y','\0'; 此 时 字 符 数 组 str 中 存 放 的 就 是 字 符 串 boy 另 外,C 语 言 也 允 许 利 用 字 符 串 常 量 来 为 一 个 字 符 数 组 赋 予 初 始 值 如 :char c[ ]= "English"; 此 时 数 组 c 的 长 度 为 8, 系 统 自 动 在 末 尾 加 了 一 个 '\0' 赋 值 运 算 符 不 可 以 拷 贝 字 符 串, 只 能 使 用 strcpy() 函 数 实 现 字 符 串 拷 贝 ; 或 者 使 用 strcat() 将 被 拷 贝 字 符 串 与 空 字 符 串 连 接 分 析 : 选 项 A 使 用 strcpy() 函 数 实 现 了 "abc" 存 储 在 数 组 a 中 ; 选 项 B 使 用 strcat() 函 数 实 现 了 "abc" 存 储 在 数 组 a 中 ; 选 项 D 使 用 循 环 语 句 实 现 了 "abc" 存 储 在 数 组 a 中 ; 而 选 项 C 则 是 无 法 实 现 字 符 串 拷 贝 的 操 作 答 案 : C 12. 设 有 下 列 函 数 原 型 和 变 量 定 义 语 句, 则 合 法 的 函 数 调 用 语 句 是 : int func( int a[], int n ); 142

143 int a[10], n, x; A. func( a, n ) = x; B. x = func( a, n ); C. x = func( a[], n ); D. x = func( a[10], n ); 知 识 点 : 函 数 调 用, 就 是 指 在 主 调 函 数 中 调 用 函 数 的 形 式 和 方 法 函 数 调 用 的 一 般 形 式 为 : 函 数 名 ( 实 参 表 列 ); 实 际 参 数 表 中 的 参 数 可 以 是 常 数 变 量 或 其 他 构 造 类 型 数 据 及 表 达 式 各 实 参 之 间 用 逗 号 分 隔 如 果 是 调 用 无 参 函 数, 则 实 参 表 列 可 以 没 有, 但 圆 括 号 不 能 省 略, 注 意 : 实 参 的 个 数 类 型 和 顺 序, 应 该 与 被 调 用 函 数 所 要 求 的 参 数 个 数 类 型 和 顺 序 一 致, 才 能 正 确 地 进 行 数 据 传 递 分 析 : 赋 值 运 算 符 的 功 能 是 : 将 赋 值 运 算 符 右 边 表 达 式 的 值 赋 给 其 左 边 的 变 量 而 选 项 A 的 书 写 格 式 与 赋 值 运 算 符 的 语 法 规 定 不 相 符, 选 项 C 和 D 调 用 函 数 func 的 第 1 个 实 参 的 表 示 方 法 错, 按 函 数 func 定 义 可 知,func 时 第 1 个 实 参 是 数 组 名 或 指 向 数 组 的 指 针 变 量 名 ; 选 项 B 调 用 函 数 func 的 第 1 个 实 参 为 数 组 名 a, 第 2 个 实 参 为 整 型 变 量 n, 所 以 是 正 确 的 答 案 : B 13. 若 有 以 下 定 义, 输 出 字 母 M 的 语 句 是 : struct person ; char name[9]; int age; struct person st[10] = "john",17,"paul",19,"mary",18; A. printf("%c",st[2].name); B. printf("%c",st[3].name[1]); C. printf("%c",st[2].name[1]); D. printf("%c",st[2].name[0]); 知 识 点 : 对 结 构 成 员 的 引 用 若 已 定 义 了 一 个 结 构 体 变 量 和 基 类 型 为 同 一 结 构 体 类 型 的 指 针 变 量, 并 使 该 指 针 指 向 同 类 型 的 变 量, 则 有 3 种 形 式 来 引 用 结 构 体 变 量 中 的 成 员 结 构 体 变 量 名 也 可 以 是 已 经 定 义 的 结 构 体 数 组 的 数 组 元 素, 形 式 如 下 : (1) 结 构 体 变 量 名. 成 员 名 (2) 指 针 变 量 名 > 成 员 名 (3) (* 指 针 变 量 名 ). 成 员 名 对 内 嵌 结 构 体 变 量 成 员 的 引 用, 必 须 逐 层 使 用 成 员 名 定 位, 对 于 多 层 嵌 套 的 结 构 体, 也 是 按 照 从 最 外 层 到 最 内 层 的 顺 序 逐 层 引 用, 每 层 之 间 用 点 号 隔 开 分 析 : 选 项 A 输 出 的 是 结 构 体 数 组 元 素 st[2] 中 name 成 员, 但 是 输 出 格 式 控 制 符 不 对, 如 果 改 为 %s 则 输 出 Mary; 选 项 B 输 出 的 是 结 构 体 数 组 元 素 st[3] 中 name 成 员 中 第 2 个 字 符, 但 是 未 对 st[3] 初 始 化, 则 输 出 内 存 中 的 某 个 符 号 ; 选 项 C 输 出 的 是 结 构 体 数 组 元 素 st[2] 中 name 成 员 中 第 2 个 字 符, 即 :a; 选 项 D 输 出 的 是 结 构 体 数 组 元 素 st[2] 中 name 成 员 中 第 1 个 字 符, 即 :M 143

144 答 案 : D 14. 需 要 以 写 模 式 打 开 当 前 目 录 下 一 个 名 为 myfile.txt 的 文 本 文 件, 下 列 打 开 文 件 正 确 的 选 项 是 : A. fopen("myfile.txt","r"); B. fopen("myfile.txt","w"); C. fopen("myfile.txt","rb"); D. fopen("myfile.txt","wb"); 知 识 点 :fopen 函 数 用 来 打 开 一 个 文 件, 其 调 用 的 一 般 形 式 为 : 文 件 指 针 名 =fopen( 文 件 名, 使 用 文 件 方 式 ) 其 中, 文 件 指 针 名 必 须 是 被 说 明 为 FILE 类 型 的 指 针 变 量, 文 件 名 是 被 打 开 文 件 的 文 件 名 使 用 文 件 方 式 是 指 文 件 的 类 型 和 操 作 要 求 文 件 名 是 字 符 串 常 量 或 字 符 串 数 组 使 用 文 件 方 式 为 : w, 其 含 义 是 : 对 文 本 文 件 只 允 许 写, 不 允 许 读 分 析 : 选 项 A 表 示 以 只 读 方 式 打 开 当 前 目 录 下 一 个 名 为 myfile.txt 的 文 本 文 件 ; 选 项 B 表 示 以 写 方 式 打 开 当 前 目 录 下 一 个 名 为 myfile.txt 的 文 本 文 件 ; 选 项 C 表 示 以 只 读 方 式 打 开 二 进 制 文 件 与 题 目 要 求 不 相 符 ; 选 项 D 表 示 以 写 方 式 打 开 二 进 制 文 件 与 题 目 要 求 不 相 符 答 案 : B 15. 假 定 建 立 了 以 下 链 表 结 构 :struct node char id ; struct node *next; *head,*p; 如 下 图 所 示 : 指 针 p 指 向 一 个 新 结 点, 将 新 结 点 插 入 到 链 表 成 为 头 结 点 的 两 条 C 语 言 语 句 是 A. head=p->next; p=head; B. p->data=head; head=p; C. head=p->data; p=head; D. p->next=head; head=p; 知 识 点 : 链 表 是 动 态 地 进 行 存 储 空 间 分 配 的 一 种 结 构 每 次 分 配 一 块 空 间 可 用 来 存 放 一 个 对 象 的 数 据, 称 之 为 一 个 结 点 每 个 结 点 都 包 括 两 个 部 分 : 用 户 需 要 用 的 实 际 数 据 和 下 一 个 结 点 的 地 址 结 点 之 间 的 联 系 可 以 用 指 针 实 现 即 在 结 点 结 构 中 定 义 一 个 成 员 项 用 来 存 放 下 一 结 点 的 首 地 址, 这 个 用 于 存 放 地 址 的 成 员, 常 把 它 称 为 指 针 域 可 在 第 一 个 结 点 的 指 针 域 内 存 入 第 二 个 结 点 的 首 地 址, 在 第 二 个 结 点 的 指 针 域 内 又 存 放 第 三 个 结 点 的 首 地 址, 如 此 串 连 下 去 直 到 最 后 一 个 结 点 最 后 一 个 结 点 因 无 后 续 结 点 连 接, 其 指 针 域 可 赋 为 NULL( 表 示 空 地 址 ) 这 样 一 种 连 接 方 式, 在 数 据 结 构 中 称 为 链 表 分 析 : 选 项 A 将 链 表 头 指 针 指 向 p->next, 由 图 可 知,p->next 为 空 地 址, 这 样 的 操 作 使 链 表 为 空 ; 选 项 B 和 C 分 别 执 行 p->data=head; 和 head=p->data; 语 法 错 误,p->data 是 字 符 型 量,head 存 放 的 链 表 首 地 址, 两 者 不 能 赋 值 ; 选 项 D 执 行 p->next=head; head=p; 使 原 链 表 的 首 地 址 作 为 p->next, 即 : 使 新 结 点 成 为 原 链 表 的 第 1 个 结 点, 同 时 使 原 链 表 的 首 地 址 变 更 为 新 结 点 的 地 址, 从 而 实 现 了 新 结 点 插 入 到 链 表 成 为 头 结 点 144

145 答 案 : D 6.2 程 序 改 错 题 分 析 1. 程 序 调 试 题 1(X_2_1.C) 调 试 要 求 : 下 列 程 序 不 能 得 到 正 确 的 结 果, 它 包 含 2 个 错 误, 请 按 题 中 的 功 能 要 求, 调 试 并 修 改 该 程 序 ( 在 所 修 改 语 句 后 加 /*modified*/ 字 样 的 注 释 ), 使 其 运 行 能 得 到 正 确 的 结 果 将 结 果 ( 包 括 X_2_1.C 文 件 和 X_2_1.EXE 文 件 ) 保 存 到 目 录 C:\KS\ 中 功 能 说 明 : 计 算 半 径 为 1~n 的 圆 的 面 积, 仅 打 印 超 过 50 的 圆 面 积 如 输 入 :6 则 输 出 : r=4,square= r=5,square= r=6,square= 带 错 误 原 程 序 : #include <stdio.h> int r,n; float area; scanf("%d",&n); for (r=1,r<=n;r++) getch(); area= *r*r; if (area<50.0) continue; printf("r=%d,square=%d\n",r,area); 知 识 点 :for 语 句 的 格 式, 三 个 表 达 式 之 间 的 间 隔 符 号 是 分 号 ;printf 函 数 中 的 格 式 控 制 符 与 输 出 元 素 的 数 据 类 型 要 一 致 分 析 : 在 vc++6.0 的 环 境 下 编 译 程 序 得 到 如 图 6-1 的 结 果 图 6-1 程 序 调 试 题 1 第 1 次 编 译 信 息 145

146 由 图 可 知 for (r=1,r<=n;r++) 行 出 现 语 法 错 误, 按 for 语 句 的 语 法 应 将 其 改 为 :for (r=1;r<=n;r++) 程 序 修 改 后 再 次 编 译 后 的 信 息 见 图 6-2 运 行 程 序 后 输 出 信 息 见 图 6-3 图 6-2 程 序 调 试 题 1 第 2 次 编 译 信 息 图 6-3 程 序 调 试 题 1 第 1 次 运 行 信 息 由 图 6-3 可 知 程 序 仍 存 在 错 误, 错 在 园 面 积 的 输 出 值, 检 查 程 序 发 现 变 量 area 的 数 据 类 型 与 输 出 控 制 符 不 相 符, printf("r=%d,square=%d\n",r,area); 改 为 printf("r=%d,square=%f\n",r,area); 运 行 修 改 后 的 程 序, 其 结 果 见 图 6-4 答 案 : 图 6-4 程 序 调 试 题 1 第 2 次 运 行 信 息 146

147 #include <stdio.h> int r,n; float area; scanf("%d",&n); for (r=1;r<=n;r++)/*modified*/ getch(); area= *r*r; if (area<50.0) continue; printf("r=%d,square=%f\n",r,area);/*modified*/ 2. 程 序 调 试 题 2(X_2_2.C) 调 试 要 求 : 下 列 程 序 不 能 得 到 正 确 的 结 果, 它 包 含 3 个 错 误, 请 按 题 中 的 功 能 要 求, 调 试 并 修 改 该 程 序 ( 在 所 修 改 语 句 后 加 /*modified*/ 字 样 的 注 释 ), 使 其 运 行 能 得 到 正 确 的 结 果 将 结 果 ( 包 括 X_2_2.C 文 件 和 X_2_2.EXE 文 件 ) 保 存 到 目 录 C:\KS\ 中 功 能 说 明 : 将 输 入 的 十 进 制 整 数 n 通 过 函 数 DtoH 转 换 为 十 六 进 制 数, 并 将 转 换 结 果 以 字 符 串 形 式 输 出 如 输 入 :79 则 输 出 :4F 又 输 入 :1234 则 输 出 :4D2 带 错 误 原 程 序 ( 见 C:\KS\X_2_2.C): #include <stdio.h> int DtoH(int n,char *str) int i,d; for (i=0;n!=0,i++) d=n%16; if (d>=10) str[i]='0'+d; else str[i]='a'+d-10; n/=16; return i; int i,k,n; char str[80]; 147

148 scanf("%d",&n); k=dtoh(n,str); for (i=k-1;i>=0;i--) printf("%c",str(i)); getch(); 知 识 点 :for 语 句 的 格 式, 三 个 表 达 式 之 间 的 间 隔 符 号 是 分 号 ; 数 组 元 素 的 下 标 表 示 法, 即 : 数 组 名 [ 下 标 表 达 式 ]; 关 系 表 达 式 正 确 表 示 命 题 分 析 : 在 vc++6.0 的 环 境 下 编 译 程 序 得 到 如 图 6-5 的 结 果 图 6-5 程 序 调 试 题 2 第 1 次 编 译 信 息 由 图 可 知 for (i=0;n!=0,i++) 行 出 现 语 法 错 误, 按 for 语 句 的 语 法 应 将 其 改 为 :for (i=0;n!=0;i++); printf("%c",str(i)); 行 出 现 语 法 错 误,,str(i) 是 数 组 元 素 应 表 示 成 str[i] 将 该 行 改 为 : printf("%c",str[i]); 程 序 修 改 后 再 次 编 译 后 的 信 息 见 图 6-6 运 行 程 序 后 输 出 信 息 见 图 6-7 图 6-6 程 序 调 试 题 2 第 2 次 编 译 信 息 148

149 图 6-7 程 序 调 试 题 2 第 1 次 运 行 信 息 由 图 6-7 可 知 程 序 仍 存 在 错 误, 由 十 进 制 转 换 成 十 六 进 制 的 方 法 可 知 if (d>=10) 中 的 关 系 表 达 式 错, 应 改 为 :if (d<10), 运 行 修 改 后 的 程 序, 其 结 果 见 图 6-8 图 6-8 程 序 调 试 题 2 第 2 次 运 行 信 息 答 案 : #include <stdio.h> int DtoH(int n,char *str) int i,d; for (i=0;n!=0;i++)/*modified*/ d=n%16; if (d<10)/*modified*/ str[i]='0'+d; else str[i]='a'+d-10; n/=16; return i; 149

150 int i,k,n; char str[80]; scanf("%d",&n); k=dtoh(n,str); for (i=k-1;i>=0;i--) printf("%c",str[i]);/*modified*/ getch(); 3. 程 序 调 试 题 3(X_2_3.C) 调 试 要 求 : 下 列 程 序 不 能 得 到 正 确 的 结 果, 它 包 含 3 个 错 误, 请 按 题 中 的 功 能 要 求, 调 试 并 修 改 该 程 序 ( 在 所 修 改 语 句 后 加 /*modified*/ 字 样 的 注 释 ), 使 其 运 行 能 得 到 正 确 的 结 果 将 结 果 ( 包 括 X_2_3.C 文 件 和 X_2_3.EXE 文 件 ) 保 存 到 目 录 C:\KS\ 中 功 能 说 明 : 函 数 fun 分 别 统 计 字 符 串 中 大 写 字 母 和 小 写 字 母 的 个 数, 函 数 完 成 字 符 串 的 输 入 和 统 计 数 的 输 出 如 输 入 :AAaaBBb123CCccccd 则 输 出 :upper=6,lower=8 带 错 误 原 程 序 ( 见 C:\KS\X_2_3.C): #include <stdio.h> void fun(char *s, int *a, int *b) while (*s=='\0') if(*s>='a' && *s<='z') (*a)++; if (*s>='a' *s<='z') (*b)++; s++; char s[100]; int upper=0, lower=0; gets(s); fun(s,&upper,&lower); printf("\nupper=%d,lower=%d\n",upper,&lower); getch(); 知 识 点 :printf 函 数 中 的 输 出 对 象 是 变 量 名 表 达 式, 不 是 变 量 的 地 址 ; 字 符 串 的 结 束 标 志 150

151 为 '\0', 判 断 字 符 串 的 结 束 是 否 结 束 的 方 法 为 :while (* 字 符 串 指 针!='\0') 字 符 串 指 针 ++; 判 断 变 量 在 某 一 区 间 内 应 使 用 逻 辑 运 算 符 号 && 将 两 个 关 系 式 连 接 分 析 : 在 vc++6.0 的 环 境 下 运 行 程 序 得 到 如 图 6-9 的 结 果 图 6-9 程 序 调 试 题 3 第 1 次 运 行 信 息 由 运 行 结 果 发 现 输 出 项 lower 在 输 出 函 数 中 的 表 现 方 式 错, printf("\nupper=%d,lower=%d\n",upper,&lower); 所 输 出 的 是 lower 的 地 址, 正 确 的 表 示 为 printf("\nupper=%d,lower=%d\n",upper,lower); 另 外,upper 的 值 为 0 也 是 错 的, 其 原 因 一 定 在 fun 函 数 中, 检 查 fun 函 数 的 定 义 发 现 while (*s=='\0') 错,'\0' 是 字 符 串 结 束 标 志, 在 循 环 中 对 字 符 串 中 的 字 符 进 行 判 断, 当 字 符 串 结 束 时 结 束 循 环, 因 此, 循 环 判 断 条 件 为 :(*s!='\0'); 判 断 字 符 是 否 为 小 写 字 母 的 条 件 应 为 :(*s>='a' && *s<='z') 而 原 程 序 中 却 为 :(*s>='a' *s<='z'), 程 序 修 改 后 的 运 行 结 果 见 图 6-10 图 6-10 程 序 调 试 题 3 第 2 次 运 行 信 息 答 案 : #include <stdio.h> void fun(char *s, int *a, int *b) while (*s!='\0')/*modified*/ if(*s>='a' && *s<='z') (*a)++; if (*s>='a'&&*s<='z')/*modified*/ (*b)++; s++; char s[100]; int upper=0, lower=0; gets(s); 151