<453A5C C435CB3F6B0E65C43D3EFD1D4C9EEB6C8BDE2C6CA5C43D3EFD1D4C9EEB6C8BDE2C6CA5FB1EAD7BC5C43D3EFD1D4C9EEB6C8BDE2C6CA5FB1EAD7BC5C43D3EFD1D4C9EEB6C8BDE2C6CA5FB1EAD7BC312E646F63>

Transcription

1 C 语 言 深 度 解 剖 解 开 程 序 员 面 试 笔 试 的 秘 密 以 含 金 量 勇 敢 挑 战 国 内 外 同 类 书 籍 陈 正 冲 编 著 石 虎 审 阅

2 写 在 前 言 前 面 的 话 最 近 面 试 了 一 些 人, 包 括 应 届 本 科 硕 士 和 工 作 多 年 的 程 序 员, 在 问 到 C 语 言 相 关 的 问 题 的 时 候, 总 是 没 几 个 人 能 完 全 答 上 我 的 问 题 甚 至 一 些 工 作 多 年, 简 历 上 写 着 最 得 意 的 语 言 是 C 语 言, 对 C 有 很 深 的 研 究, 精 通 C 语 言 的 人 也 答 不 完 全 我 的 问 题, 甚 至 有 个 别 人 我 问 的 问 题 一 个 都 答 不 上 于 是 我 就 想 起 了 我 去 年 闲 的 使 用 写 的 这 本 小 册 子 这 本 小 册 子 已 经 在 我 电 脑 里 睡 了 一 年 大 觉 了 并 非 没 有 出 版 社 愿 意 出 版, 而 是 几 个 大 的 出 版 社 都 认 为 书 写 得 不 错, 但 太 薄, 利 润 太 低, 所 以 要 求 我 加 厚 到 300 页 以 上 我 拒 绝 加 厚, 并 为 此 和 几 个 出 版 社 僵 持 了 一 年 多 我 认 为 经 典 的 东 西 一 定 要 精 炼, 不 要 废 话 这 次 由 于 面 试 别 人, 所 以 终 于 记 起 了 我 还 写 过 这 么 一 本 小 册 子 想 了 想, 还 是 决 定 挂 到 网 上 免 费 让 大 家 看 得 了 并 为 此 专 门 为 本 书 开 了 个 博 客, 以 方 便 和 读 者 交 流 博 客 地 址 : 作 者 简 介 : 陈 正 冲 : 湖 南 沅 江 人, 毕 业 于 长 春 光 学 精 密 机 械 学 院 ( 长 春 理 工 大 学 ) 数 学 系 目 前 从 事 嵌 入 式 软 件 开 发 和 管 理 方 面 的 工 作 石 虎 : 湖 南 沅 江 人, 毕 业 于 吉 林 大 学 计 算 机 系 目 前 为 大 连 交 通 大 学 计 算 机 系 讲 师

3 前 言 我 遇 到 过 很 多 程 序 员 和 计 算 机 系 毕 业 的 学 生, 也 给 很 多 程 序 员 和 计 算 机 系 毕 业 的 学 生 讲 解 过 高 级 C 语 言 程 序 设 计 每 期 班 开 课 前, 我 总 会 问 学 生 : 你 感 觉 C 语 言 学 得 怎 么 样? 难 吗? 指 针 明 白 吗? 数 组 呢? 内 存 管 理 呢? 往 往 学 生 回 答 说 : 感 觉 还 可 以,C 语 言 不 难, 指 针 很 明 白, 数 组 很 简 单, 内 存 管 理 也 不 难 一 般 我 会 再 问 一 个 问 题 : 通 过 这 个 班 的 学 习, 你 想 达 到 什 么 程 度? 很 多 学 生 回 答 : 精 通 C 语 言 我 告 诉 他 们 : 我 很 无 奈, 也 很 无 语 因 为 我 完 全 在 和 一 群 业 余 者 或 者 是 C 语 言 爱 好 者 在 对 话 你 们 大 学 的 计 算 机 教 育 根 本 就 是 在 浪 费 你 们 的 时 间, 念 了 几 年 大 学, 连 C 语 言 的 门 都 没 摸 着 现 在 大 多 数 学 校 计 算 机 系 都 开 了 C C++ Java C# 等 等 语 言, 好 像 什 么 都 学 了, 但 是 什 么 都 不 会, 更 可 悲 的 是 有 些 大 学 居 然 取 消 了 C 语 言 课 程, 认 为 其 过 时 了 我 个 人 的 观 点 是 十 鸟 在 林, 不 如 一 鸟 在 手, 真 正 把 C 语 言 整 明 白 了 再 学 别 的 语 言 也 很 简 单, 如 果 C 语 言 都 没 整 明 白, 别 的 语 言 学 得 再 好 也 是 花 架 子, 因 为 你 并 不 了 解 底 层 是 怎 么 回 事 当 然 我 也 从 来 不 认 为 一 个 没 学 过 汇 编 的 人 能 真 正 掌 握 C 语 言 的 真 谛 我 个 人 一 直 认 为, 普 通 人 用 C 语 言 在 3 年 之 下, 一 般 来 说, 还 没 掌 握 C 语 言 ;5 年 之 下, 一 般 来 说 还 没 熟 悉 C 语 言 ;10 年 之 下, 谈 不 上 精 通 所 以, 我 告 诉 我 的 学 生 : 听 完 我 的 课, 远 达 不 到 精 通 的 目 标, 熟 悉 也 达 不 到, 掌 握 也 达 不 到 那 能 达 到 什 么 目 标?----- 领 你 们 进 入 C 语 言 的 大 门 入 门 之 后 的 造 化 如 何 在 于 你 们 自 己 不 过 我 可 以 告 诉 你 们 一 条 不 是 捷 径 的 捷 径 : 把 一 个 键 盘 的 F10 或 F11 按 坏, 当 然 不 能 是 垃 圾 键 盘 往 往 讲 到 这 里, 学 生 眼 里 总 是 透 露 着 疑 虑 C 语 言 有 这 么 难 吗? 我 的 回 答 是 : 不 难 但 你 就 是 用 不 明 白 学 生 说 : 以 前 大 学 老 师 讲 C 语 言, 我 学 得 很 好 老 师 讲 的 都 能 听 懂, 考 试 也 很 好 平 时 练 习 感 觉 自 己 还 不 错, 工 作 也 很 轻 松 找 到 了 我 告 诉 学 生 : 听 明 白, 看 明 白 不 代 表 你 懂 了, 你 懂 了 不 代 表 你 会 用 了, 你 会 用 了 不 代 表 你 能 用 明 白, 你 能 用 明 白 不 代 表 你 真 正 懂 了! 什 么 时 候 表 明 你 真 正 懂 了 呢? 你 站 在 我 这 来, 把 问 题 给 下 面 的 同 学 讲 明 白, 学 生 都 听 明 白 了, 说 明 你 真 正 懂 了 否 则, 你 就 没 真 正 懂, 这 是 检 验 懂 没 懂 的 唯 一 标 准 冰 山 大 家 都 没 见 过, 但 总 听 过 或 是 电 影 里 看 过 吧? 如 果 你 连 泰 坦 尼 克 都 没 看 过, 那 你 也 算 个 人 物 ( 开 个 玩 笑 ) 泰 坦 尼 克 里 的 冰 山 给 泰 坦 尼 克 造 成 了 巨 大 的 损 失 你 们 都 是 理 工 科 的, 应 该 明 白 冰 山 在 水 面 上 的 部 分 只 是 总 个 冰 山 的 1/8 我 现 在 就 告 诉 你 们,C 语 言 就 是 这 座 冰 山 你 们 现 在 仅 仅 是 摸 到 了 水 面 上 的 部 分, 甚 至 根 本 不 知 道 水 面 下 的 部 分 我 希 望 通 过 我 的 讲 解, 让 你 们 摸 到 水 面 下 的 部 分, 让 你 们 知 道 C 语 言 到 底 是 什 么 样 子 从 现 在 开 始, 除 非 在 特 殊 情 况 下, 不 允 许 用 printf 这 个 函 数 为 什 么 呢? 很 多 学 生 写 完 代 码, 直 接 用 printf 打 印 出 来, 发 现 结 果 不 对 然 后 就 举 手 问 我 : 老 师, 我 的 结 果 为 什 么 不 对 啊? 连 调 试 的 意 识 都 没 有! 大 多 数 学 生 根 本 就 不 会 调 试, 不 会 看 变 量 的 值, 内 存 的 值 只 知 道 printf 出 来 结 果 不 对, 却 不 知 道 为 什 么 不 对, 怎 么 解 决 这 种 情 况 还 算 好 的 往 往 很 多 时 候 printf 出 来 的 结 果 是 对 的, 然 后 呢, 学 生 也 理 所 当 然 的 认 为 程 序 没 有 问 题 是 这 样 吗? 往 往 不 是, 往 后 看, 你 能 看 到 例 子 的 永 远 给 我 记 住 一 点 : 结 果 对, 并 不 代 表 程 序 真 正 没 有 问 题 所 以, 以 后 尽 量 不 要 用 printf 函 数, 要 去 看 变 量 的 值, 内 存 的 值 当 然, 在 我 们 目 前 的 编 译 器 里, 变 量 的 值, 内 存 的 值 对 了 就 代 表 你 程 序 没 问 题 吗? 也 不 是, 往 后, 你 也 会 看 到 例 子 的 这 个 时 候 呢, 学 生 往 往 会 莫 名 其 妙 这 个 老 师 有 问 题 吧 大 学 里 我 们 老 师 都 教 我 们 怎 么 用 printf, 告 诉 我 们 要 经 常 用 printf 这 也 恰 恰 是 大 学 教 育 失 败 的 地 方 之 一 很 多 大 学 老 师 根 本 就 没 真 正 用 C 语 言 写 过 几 行 代 码, 更 别 说 教 学 生 调 试 代 码 了 不 调 试 代 码, 不 按 F10 或 F11, 水 平 永 远 也 无 法 提 上 来, 所 以, 要 想 学 好 一 门 编 程 语 言, 最 好 的 办 法 就 是 多 调 试 你 去 一 个 软 件 公 司 转 转, 去 看 人 家 的 键 盘, 如 果 发 现 键 盘 上 的 F10 或 F11 铮 亮 铮 亮, 毫 无 疑 问, 此 机 的 主 人 曾 经 或 现 在 是 开 发 人 员 ( 这 里 仅 指 写 代 码 的, 不 上 升 到 架 构 设 计 类 的 开 发 人 员 ),

4 否 则, 必 是 非 开 发 人 员 非 常 有 必 要 申 明, 本 人 并 非 什 么 学 者 或 是 专 家, 但 本 人 是 数 学 系 毕 业, 所 以 对 理 论 方 面 比 较 擅 长 讲 解 的 时 候 会 举 很 多 例 子 来 尽 量 使 学 生 明 白 这 个 知 识 点, 至 于 这 些 例 子 是 否 恰 当 则 是 见 仁 见 智 的 问 题 了 但 是 一 条, 长 期 的 数 学 训 练 使 得 本 人 思 维 比 较 严 谨, 讲 解 一 些 知 识 点 尤 其 是 一 些 概 念 性 原 理 性 的 东 西 时 会 抠 的 很 细 很 严, 这 一 点 相 信 读 者 会 体 会 得 到 的 本 书 是 我 平 时 讲 解 C 语 言 的 一 些 心 得 和 经 验, 其 中 有 很 多 我 个 人 的 见 解 或 看 法 经 过 多 期 培 训 班 的 实 践, 发 现 这 样 讲 解 得 比 较 透 彻, 学 生 听 得 明 白 很 多 学 生 听 完 课 后 告 诉 我 : 我 有 生 以 来 听 课 从 来 都 没 有 听 得 这 么 透 彻, 这 么 明 白 过 也 有 业 余 班 的 学 生 甚 至 辞 掉 本 职 工 作 来 听 我 的 课 的 当 然, 关 于 C 语 言 的 这 么 多 经 验 和 心 得 的 积 累 并 非 我 一 人 之 力 借 用 一 句 名 言 : 我 只 不 过 是 站 在 巨 人 的 肩 膀 上 而 已 给 学 生 做 培 训 的 时 候 我 参 考 得 比 较 多 的 书 有 :Kernighan & Ritchie 的 The C Programming Language ;Linden 的 Expert C Programming ; Andrew & Koening C Traps and Pitfalls ; Steve Maguire 的 Write Clean Code ;Steve McConnell 的 Code Complete. Second Edition ; 林 锐 的 高 质 量 C++/C 编 程 指 南 这 些 书 都 是 经 典 之 作, 但 却 都 有 着 各 自 的 缺 陷 读 者 往 往 需 要 同 时 阅 读 这 些 书 才 能 深 刻 的 掌 握 某 一 知 识 点 我 的 讲 课 的 试 图 时 候 融 各 家 之 长, 再 加 上 我 个 人 的 见 解 传 授 给 学 生 还 好, 学 生 反 映 还 可 以, 至 少 还 没 有 出 乱 子 这 些 书 饱 含 着 作 者 的 智 慧, 每 读 一 遍 都 有 不 同 的 收 获, 我 希 望 读 者 能 读 上 十 遍 另 外, 在 编 写 本 书 时 也 参 考 了 网 上 一 些 无 名 高 手 的 文 章, 这 些 高 手 的 文 章 见 解 深 刻, 使 我 受 益 匪 浅 这 里 要 感 谢 这 些 大 师 们, 如 果 不 是 他 们, 肯 怕 我 的 C 语 言 的 水 平 也 仅 仅 是 入 门 而 已 学 习 C 语 言, 这 几 本 书 如 果 真 正 啃 透 了, 水 平 不 会 差 到 哪 与 其 说 本 书 是 我 授 课 的 经 验 与 心 得, 不 如 说 本 书 是 我 对 这 些 大 师 们 智 慧 的 解 读 本 书 并 不 是 从 头 到 尾 讲 解 C 语 言 的 基 础 知 识, 所 以, 本 书 并 不 适 用 于 C 语 言 零 基 础 的 人 本 书 的 知 识 要 比 一 般 的 C 语 言 书 说 讲 的 深 的 多, 其 中 有 很 多 问 题 是 各 大 公 司 的 面 试 或 笔 试 题 所 以 本 书 的 读 者 应 该 是 中 国 广 大 的 计 算 机 系 的 学 生 和 初 级 程 序 员 如 果 本 书 上 面 的 问 题 能 真 正 明 白 80%, 作 为 一 个 应 届 毕 业 生, 肯 怕 没 有 一 家 大 公 司 会 拒 绝 你 当 然, 书 内 很 多 知 识 也 值 得 计 算 机 教 师 或 是 中 高 级 程 序 员 参 考 尤 其 书 内 的 一 些 例 子 或 比 方, 如 果 能 被 广 大 教 师 用 于 课 堂, 我 想 对 学 生 来 说 是 件 非 常 好 的 事 情 有 人 说 电 影 是 一 门 遗 憾 的 艺 术, 因 为 在 编 辑 完 成 之 后 总 能 或 多 或 少 的 发 现 一 些 本 来 可 以 做 得 更 好 的 缺 陷 讲 课 同 样 也 如 此, 每 次 讲 完 课 之 后 总 能 发 现 自 己 某 些 地 方 或 是 没 有 讲 到, 或 是 没 能 讲 透 彻 或 是 忘 了 举 一 个 轻 浅 的 例 子 等 等 整 理 本 书 的 过 程 也 是, 为 了 尽 量 精 炼, 总 是 犹 豫 一 些 东 西 的 去 留 限 于 作 者 水 平, 书 中 难 免 有 些 遗 漏 甚 至 错 误, 希 望 各 位 读 者 能 予 指 教 作 者 Mail:dissection_c@163.com. 陈 正 冲 2008 年 6 月 23 日

5 目 录 第 一 章 关 键 字 , 最 宽 恒 大 量 的 关 键 字 ----auto , 最 快 的 关 键 字 ---- register , 皇 帝 身 边 的 小 太 监 ---- 寄 存 器 , 使 用 register 修 饰 符 的 注 意 点 , 最 名 不 符 实 的 关 键 字 ----static , 修 饰 变 量 , 修 饰 函 数 , 基 本 数 据 类 型 ----short int long char float double , 数 据 类 型 与 模 子 , 变 量 的 命 名 规 则 , 最 冤 枉 的 关 键 字 ----sizeof , 常 年 被 人 误 认 为 函 数 ,sizeof(int)*p 表 示 什 么 意 思? ,signed unsigned 关 键 字 ,if else 组 合 ,bool 变 量 与 零 值 进 行 比 较 , float 变 量 与 零 值 进 行 比 较 , 指 针 变 量 与 零 值 进 行 比 较 ,else 到 底 与 哪 个 if 配 对 呢? ,if 语 句 后 面 的 分 号 , 使 用 if 语 句 的 其 他 注 意 事 项 ,switch case 组 合 , 不 要 拿 青 龙 偃 月 刀 去 削 苹 果 ,case 关 键 字 后 面 的 值 有 什 么 要 求 吗? ,case 语 句 的 排 列 顺 序 , 使 用 case 语 句 的 其 他 注 意 事 项 ,do while for 关 键 字 ,break 与 continue 的 区 别 , 循 环 语 句 的 注 意 点 ,goto 关 键 字 ,void 关 键 字 ,void a? ,return 关 键 字 ,const 关 键 字 也 许 该 被 替 换 为 readolny , 节 省 空 间, 避 免 不 必 要 的 内 存 分 配, 同 时 提 高 效 率 , 最 易 变 的 关 键 字 ----volatile , 最 会 带 帽 子 的 关 键 字 ----extern ,struct 关 键 字 , 空 结 构 体 多 大? , 柔 性 数 组 ,struct 与 class 的 区 别 ,union 关 键 字...40

6 1.15.1, 大 小 端 模 式 对 union 类 型 数 据 的 影 响 , 如 何 用 程 序 确 认 当 前 系 统 的 存 储 模 式? ,enum 关 键 字 , 枚 举 类 型 的 使 用 方 法 , 枚 举 与 #define 宏 的 区 别 , 伟 大 的 缝 纫 师 ----typedef 关 键 字 , 关 于 马 甲 的 笑 话 , 历 史 的 误 会 ---- 也 许 应 该 是 typerename ,typedef 与 #define 的 区 别 ,#define a int[10] 与 typedef int a[10]; 第 二 章 符 号 , 注 释 符 号 , 几 个 似 非 而 是 的 注 释 问 题 ,y = x/*p , 怎 样 才 能 写 出 出 色 的 注 释 , 安 息 吧, 路 德 维 希. 凡. 贝 多 芬 ,windows 大 师 们 用 注 释 讨 论 天 气 问 题 , 出 色 注 释 的 基 本 要 求 , 接 续 符 和 转 义 符 , 单 引 号 双 引 号 , 逻 辑 运 算 符 , 位 运 算 符 , 左 移 和 右 移 ,0x01<<2+3 的 值 为 多 少? , 花 括 号 ,++ -- 操 作 符 ,++i+++i+++i , 贪 心 法 ,2/(-2) 的 值 是 多 少? , 运 算 符 的 优 先 级 , 运 算 符 的 优 先 级 表 , 一 些 容 易 出 错 的 优 先 级 问 题 第 三 章 预 处 理 , 宏 定 义 , 数 值 宏 常 量 , 字 符 串 宏 常 量 , 用 define 宏 定 义 注 释 符 号? , 用 define 宏 定 义 表 达 式 , 宏 定 义 中 的 空 格 ,#undef , 条 件 编 译 , 文 件 包 含 ,#error 预 处 理 ,#line 预 处 理...67

7 3.6,#pragma 预 处 理 ,#pragma pack , 为 什 么 会 有 内 存 对 齐? , 如 何 避 免 内 存 对 齐 的 影 响 , # 运 算 符 ,## 预 算 符...72 第 四 章 指 针 和 数 组 , 指 针 , 指 针 的 内 存 布 局 , * 与 防 盗 门 的 钥 匙 ,int *p = NULL 和 *p = NULL 有 什 么 区 别? , 如 何 将 数 值 存 储 到 指 定 的 内 存 地 址 , 编 译 器 的 bug? , 如 何 达 到 手 中 无 剑 胸 中 也 无 剑 的 地 步 , 数 组 , 数 组 的 内 存 布 局 , 数 组 名 a 作 为 左 值 和 右 值 的 区 别 , 指 针 与 数 组 之 间 的 恩 恩 怨 怨 , 以 指 针 的 形 式 访 问 和 以 下 标 的 形 式 访 问 , 以 指 针 的 形 式 访 问 和 以 下 标 的 形 式 访 问 指 针 , 以 指 针 的 形 式 访 问 和 以 下 标 的 形 式 访 问 数 组 ,a 和 &a 的 区 别 , 指 针 和 数 组 的 定 义 与 声 明 , 定 义 为 数 组, 声 明 为 指 针 , 定 义 为 指 针, 声 明 为 数 组 , 指 针 和 数 组 的 对 比 , 指 针 数 组 和 数 组 指 针 , 指 针 数 组 和 数 组 指 针 的 内 存 布 局 , 再 论 a 和 &a 之 间 的 区 别 , 地 址 的 强 制 转 换 , 多 维 数 组 与 多 级 指 针 , 二 维 数 组 , 假 想 中 的 二 维 数 组 布 局 , 内 存 与 尺 子 的 对 比 ,&p[4][2] - &a[4][2] 的 值 为 多 少? , 二 级 指 针 , 二 级 指 针 的 内 存 布 局 , 数 组 参 数 与 指 针 参 数 , 一 维 数 组 参 数 , 能 否 向 函 数 传 递 一 个 数 组? , 无 法 向 函 数 传 递 一 个 数 组 , 一 级 指 针 参 数 , 能 否 把 指 针 变 量 本 身 传 递 给 一 个 函 数 , 无 法 把 指 针 变 量 本 身 传 递 给 一 个 函 数... 98

8 4.6.3, 二 维 数 组 参 数 与 二 维 指 针 参 数 , 函 数 指 针 , 函 数 指 针 的 定 义 , 函 数 指 针 的 使 用 , 函 数 指 针 使 用 的 例 子 ,*(int*)&p ---- 这 是 什 么? ,(*(void(*) ())0)() 这 是 什 么? , 函 数 指 针 数 组 , 函 数 指 针 数 组 的 指 针 第 五 章 内 存 管 理 , 什 么 是 野 指 针 , 栈 堆 和 静 态 区 , 常 见 的 内 存 错 误 及 对 策 , 指 针 没 有 指 向 一 块 合 法 的 内 存 , 结 构 体 成 员 指 针 未 初 始 化 , 没 有 为 结 构 体 指 针 分 配 足 够 的 内 存 , 函 数 的 入 口 校 验 , 为 指 针 分 配 的 内 存 太 小 , 内 存 分 配 成 功, 但 并 未 初 始 化 , 内 存 越 界 , 内 存 泄 漏 , 告 老 还 乡 求 良 田 , 如 何 使 用 malloc 函 数 , 用 malloc 函 数 申 请 0 字 节 内 存 , 内 存 释 放 , 内 存 释 放 之 后 , 内 存 已 经 被 释 放 了, 但 是 继 续 通 过 指 针 来 使 用 第 六 章 函 数 , 函 数 的 由 来 与 好 处 , 编 码 风 格 , 函 数 设 计 的 一 般 原 则 和 技 巧 , 函 数 递 归 , 一 个 简 单 但 易 出 错 的 递 归 例 子 , 不 使 用 任 何 变 量 编 写 strlen 函 数 第 七 章 文 件 结 构 , 文 件 内 容 的 一 般 规 则 , 文 件 名 命 名 的 规 则...130

9 第 一 章 关 键 字 每 次 讲 关 键 字 之 前, 我 总 是 问 学 生 :C 语 言 有 多 少 个 关 键 字?sizeof 怎 么 用? 它 是 函 数 吗? 有 些 学 生 不 知 道 C 语 言 有 多 少 个 关 键 字, 大 多 数 学 生 往 往 告 诉 我 sizeof 是 函 数, 因 为 它 后 面 跟 着 一 对 括 号 当 投 影 仪 把 这 32 个 关 键 字 投 到 幕 布 上 时, 很 多 学 生 表 情 惊 讶 有 些 关 键 字 从 来 没 见 过, 有 的 惊 讶 C 语 言 关 键 字 竟 有 32 个 之 多 更 有 甚 者, 说 大 学 老 师 告 诉 他 们 sizeof 是 函 数, 没 想 到 它 居 然 是 关 键 字! 由 此 可 想 而 知, 大 学 的 计 算 机 教 育 是 多 么 失 败! 表 (1.1)C 语 言 标 准 定 义 的 32 个 关 键 字 关 键 字 意 义 auto int double long char float short signed unsigned struct union enum static switch case default break register const volatile 声 明 自 动 变 量, 缺 省 时 编 译 器 一 般 默 认 为 auto 声 明 整 型 变 量 声 明 双 精 度 变 量 声 明 长 整 型 变 量 声 明 字 符 型 变 量 声 明 浮 点 型 变 量 声 明 短 整 型 变 量 声 明 有 符 号 类 型 变 量 声 明 无 符 号 类 型 变 量 声 明 结 构 体 变 量 声 明 联 合 数 据 类 型 声 明 枚 举 类 型 声 明 静 态 变 量 用 于 开 关 语 句 开 关 语 句 分 支 开 关 语 句 中 的 其 他 分 支 跳 出 当 前 循 环 声 明 寄 存 器 变 量 声 明 只 读 变 量 说 明 变 量 在 程 序 执 行 中 可 被 隐 含 地 改 变 typedef 用 以 给 数 据 类 型 取 别 名 ( 当 然 还 有 其 他 作 用 )

10 extern 声 明 变 量 是 在 其 他 文 件 正 声 明 ( 也 可 以 看 做 是 引 用 变 量 ) return 子 程 序 返 回 语 句 ( 可 以 带 参 数, 也 可 不 带 参 数 ) void continue do while if 声 明 函 数 无 返 回 值 或 无 参 数, 声 明 空 类 型 指 针 结 束 当 前 循 环, 开 始 下 一 轮 循 环 循 环 语 句 的 循 环 体 循 环 语 句 的 循 环 条 件 条 件 语 句 else 条 件 语 句 否 定 分 支 ( 与 if 连 用 ) for 一 种 循 环 语 句 ( 可 意 会 不 可 言 传 ) goto sizeof 无 条 件 跳 转 语 句 计 算 对 象 所 占 内 存 空 间 大 小 下 面 的 篇 幅 就 一 一 讲 解 这 些 关 键 字 但 在 讲 解 之 前 先 明 确 两 个 概 念 : 什 么 是 定 义? 什 么 是 声 明? 它 们 有 何 区 别? 举 个 例 子 : A)int i; B)extern int i;( 关 于 extern, 后 面 解 释 ) 哪 个 是 定 义? 哪 个 是 声 明? 或 者 都 是 定 义 或 者 都 是 声 明? 我 所 教 过 的 学 生 几 乎 没 有 一 人 能 回 答 上 这 个 问 题 这 个 十 分 重 要 的 概 念 在 大 学 里 从 来 没 有 被 提 起 过! 什 么 是 定 义 : 所 谓 的 定 义 就 是 ( 编 译 器 ) 创 建 一 个 对 象, 为 这 个 对 象 分 配 一 块 内 存 并 给 它 取 上 一 个 名 字, 这 个 名 字 就 是 我 们 经 常 所 说 的 变 量 名 或 对 象 名 但 注 意, 这 个 名 字 一 旦 和 这 块 内 存 匹 配 起 来 ( 可 以 想 象 是 这 个 名 字 嫁 给 了 这 块 空 间, 没 有 要 彩 礼 啊 ^_^), 它 们 就 同 生 共 死, 终 生 不 离 不 弃 并 且 这 块 内 存 的 位 置 也 不 能 被 改 变 一 个 变 量 或 对 象 在 一 定 的 区 域 内 ( 比 如 函 数 内, 全 局 等 ) 只 能 被 定 义 一 次, 如 果 定 义 多 次, 编 译 器 会 提 示 你 重 复 定 义 同 一 个 变 量 或 对 象 什 么 是 声 明 : 有 两 重 含 义, 如 下 : 第 一 重 含 义 : 告 诉 编 译 器, 这 个 名 字 已 经 匹 配 到 一 块 内 存 上 了 ( 伊 人 已 嫁, 吾 将 何 去 何 从? 何 以 解 忧, 唯 有 稀 粥 ), 下 面 的 代 码 用 到 变 量 或 对 象 是 在 别 的 地 方 定 义 的 声 明 可 以 出 现 多 次 第 二 重 含 义 : 告 诉 编 译 器, 我 这 个 名 字 我 先 预 定 了, 别 的 地 方 再 也 不 能 用 它 来 作 为 变 量 名 或 对 象 名 比 如 你 在 图 书 馆 自 习 室 的 某 个 座 位 上 放 了 一 本 书, 表 明 这 个 座 位 已 经 有 人 预 订, 别 人 再 也 不 允 许 使 用 这 个 座 位 其 实 这 个 时 候 你 本 人 并 没 有 坐 在 这 个 座 位 上 这 种 声 明 最 典 型 的 例 子 就 是 函 数 参 数 的 声 明, 例 如 : void fun(int i, char c); 好, 这 样 一 解 释, 我 们 可 以 很 清 楚 的 判 断 :A) 是 定 义 ;B) 是 声 明 那 他 们 的 区 别 也 很 清 晰 了 记 住, 定 义 声 明 最 重 要 的 区 别 : 定 义 创 建 了 对 象 并 为 这 个

11 对 象 分 配 了 内 存, 声 明 没 有 分 配 内 存 ( 一 个 抱 伊 人, 一 个 喝 稀 粥 ^_^) 1.1, 最 宽 恒 大 量 的 关 键 字 ----auto auto: 它 很 宽 恒 大 量 的, 你 就 当 它 不 存 在 吧 编 译 器 在 默 认 的 缺 省 情 况 下, 所 有 变 量 都 是 auto 的 1.2, 最 快 的 关 键 字 ---- register register: 这 个 关 键 字 请 求 编 译 器 尽 可 能 的 将 变 量 存 在 CPU 内 部 寄 存 器 中 而 不 是 通 过 内 存 寻 址 访 问 以 提 高 效 率 注 意 是 尽 可 能, 不 是 绝 对 你 想 想, 一 个 CPU 的 寄 存 器 也 就 那 么 几 个 或 几 十 个, 你 要 是 定 义 了 很 多 很 多 register 变 量, 它 累 死 也 可 能 不 能 全 部 把 这 些 变 量 放 入 寄 存 器 吧, 轮 也 可 能 轮 不 到 你 1.2.1, 皇 帝 身 边 的 小 太 监 ---- 寄 存 器 不 知 道 什 么 是 寄 存 器? 那 见 过 太 监 没 有? 没 有? 其 实 我 也 没 有 没 见 过 不 要 紧, 见 过 就 麻 烦 大 了 ^_^, 大 家 都 看 过 古 装 戏, 那 些 皇 帝 们 要 阅 读 奏 章 的 时 候, 大 臣 总 是 先 将 奏 章 交 给 皇 帝 旁 边 的 小 太 监, 小 太 监 呢 再 交 给 皇 帝 同 志 处 理 这 个 小 太 监 只 是 个 中 转 站, 并 无 别 的 功 能 好, 那 我 们 再 联 想 到 我 们 的 CPU CPU 不 就 是 我 们 的 皇 帝 同 志 么? 大 臣 就 相 当 于 我 们 的 内 存, 数 据 从 他 这 拿 出 来 那 小 太 监 就 是 我 们 的 寄 存 器 了 ( 这 里 先 不 考 虑 CPU 的 高 速 缓 存 区 ) 数 据 从 内 存 里 拿 出 来 先 放 到 寄 存 器, 然 后 CPU 再 从 寄 存 器 里 读 取 数 据 来 处 理, 处 理 完 后 同 样 把 数 据 通 过 寄 存 器 存 放 到 内 存 里,CPU 不 直 接 和 内 存 打 交 道 这 里 要 说 明 的 一 点 是 : 小 太 监 是 主 动 的 从 大 臣 手 里 接 过 奏 章, 然 后 主 动 的 交 给 皇 帝 同 志, 但 寄 存 器 没 这 么 自 觉, 它 从 不 主 动 干 什 么 事 一 个 皇 帝 可 能 有 好 些 小 太 监, 那 么 一 个 CPU 也 可 以 有 很 多 寄 存 器, 不 同 型 号 的 CPU 拥 有 寄 存 器 的 数 量 不 一 样 为 啥 要 这 么 麻 烦 啊? 速 度! 就 是 因 为 速 度 寄 存 器 其 实 就 是 一 块 一 块 小 的 存 储 空 间, 只 不 过 其 存 取 速 度 要 比 内 存 快 得 多 进 水 楼 台 先 得 月 嘛, 它 离 CPU 很 近,CPU 一 伸 手 就 拿 到 数 据 了, 比 在 那 么 大 的 一 块 内 存 里 去 寻 找 某 个 地 址 上 的 数 据 是 不 是 快 多 了? 那 有 人 问 既 然 它 速 度 那 么 快, 那 我 们 的 内 存 硬 盘 都 改 成 寄 存 器 得 了 呗 我 要 说 的 是 : 你 真 有 钱! 1.2.2, 使 用 register 修 饰 符 的 注 意 点 虽 然 寄 存 器 的 速 度 非 常 快, 但 是 使 用 register 修 饰 符 也 有 些 限 制 的 :register 变 量 必 须 是 能 被 CPU 寄 存 器 所 接 受 的 类 型 意 味 着 register 变 量 必 须 是 一 个 单 个 的 值, 并 且 其 长 度 应 小 于 或 等 于 整 型 的 长 度 而 且 register 变 量 可 能 不 存 放 在 内 存 中, 所 以 不 能 用 取 址 运 算 符 & 来 获 取 register 变 量 的 地 址

12 1.3, 最 名 不 符 实 的 关 键 字 ----static 不 要 误 以 为 关 键 字 static 很 安 静, 其 实 它 一 点 也 不 安 静 这 个 关 键 字 在 C 语 言 里 主 要 有 两 个 作 用,C++ 对 它 进 行 了 扩 展 1.3.1, 修 饰 变 量 第 一 个 作 用 : 修 饰 变 量 变 量 又 分 为 局 部 和 全 局 变 量, 但 它 们 都 存 在 内 存 的 静 态 区 静 态 全 局 变 量, 作 用 域 仅 限 于 变 量 被 定 义 的 文 件 中, 其 他 文 件 即 使 用 extern 声 明 也 没 法 使 用 他 准 确 地 说 作 用 域 是 从 定 义 之 处 开 始, 到 文 件 结 尾 处 结 束, 在 定 义 之 处 前 面 的 那 些 代 码 行 也 不 能 使 用 它 想 要 使 用 就 得 在 前 面 再 加 extern *** 恶 心 吧? 要 想 不 恶 心, 很 简 单, 直 接 在 文 件 顶 端 定 义 不 就 得 了 静 态 局 部 变 量, 在 函 数 体 里 面 定 义 的, 就 只 能 在 这 个 函 数 里 用 了, 同 一 个 文 档 中 的 其 他 函 数 也 用 不 了 由 于 被 static 修 饰 的 变 量 总 是 存 在 内 存 的 静 态 区, 所 以 即 使 这 个 函 数 运 行 结 束, 这 个 静 态 变 量 的 值 还 是 不 会 被 销 毁, 函 数 下 次 使 用 时 仍 然 能 用 到 这 个 值 static int j; void fun1(void) static int i = 0; i++; void fun2(void) j=0; j++; int main() for(k=0; k<10; k++) fun1(); fun2(); return 0;

13 i 和 j 的 值 分 别 是 什 么, 为 什 么? 1.3.2, 修 饰 函 数 第 二 个 作 用 : 修 饰 函 数 函 数 前 加 static 使 得 函 数 成 为 静 态 函 数 但 此 处 static 的 含 义 不 是 指 存 储 方 式, 而 是 指 对 函 数 的 作 用 域 仅 局 限 于 本 文 件 ( 所 以 又 称 内 部 函 数 ) 使 用 内 部 函 数 的 好 处 是 : 不 同 的 人 编 写 不 同 的 函 数 时, 不 用 担 心 自 己 定 义 的 函 数, 是 否 会 与 其 它 文 件 中 的 函 数 同 名 关 键 字 static 有 着 不 寻 常 的 历 史 起 初, 在 C 中 引 入 关 键 字 static 是 为 了 表 示 退 出 一 个 块 后 仍 然 存 在 的 局 部 变 量 随 后,static 在 C 中 有 了 第 二 种 含 义 : 用 来 表 示 不 能 被 其 它 文 件 访 问 的 全 局 变 量 和 函 数 为 了 避 免 引 入 新 的 关 键 字, 所 以 仍 使 用 static 关 键 字 来 表 示 这 第 二 种 含 义 当 然,C++ 里 对 static 赋 予 了 第 三 个 作 用, 这 里 先 不 讨 论, 有 兴 趣 的 可 以 找 相 关 资 料 研 究 1.4, 基 本 数 据 类 型 ----short int long char float double 短 整 型 short C 语 言 包 含 的 数 据 类 型 如 下 图 所 示 : 整 整 型 int 型 数 值 类 型 长 整 型 long 单 精 度 型 float 基 本 类 型 浮 点 型 字 符 类 型 char 双 精 度 型 double C 数 据 类 型 构 造 类 型 指 针 类 型 数 组 结 构 体 struct 共 用 体 union 枚 举 类 型 enum 空 类 型 void

14 1.4.1, 数 据 类 型 与 模 子 short int long char float double 这 六 个 关 键 字 代 表 C 语 言 里 的 六 种 基 本 数 据 类 型 怎 么 去 理 解 它 们 呢? 举 个 例 子 : 见 过 藕 煤 球 的 那 个 东 西 吧?( 没 见 过? 煤 球 总 见 过 吧 ) 那 个 东 西 叫 藕 煤 器, 拿 着 它 在 和 好 的 煤 堆 里 这 么 一 咔, 一 个 煤 球 出 来 了 半 径 12cm,12 个 孔 不 同 型 号 的 藕 煤 器 咔 出 来 的 煤 球 大 小 不 一 样, 孔 数 也 不 一 样 这 个 藕 煤 器 其 实 就 是 个 模 子 现 在 我 们 联 想 一 下,short int long char float double 这 六 个 东 东 是 不 是 很 像 不 同 类 型 的 藕 煤 器 啊? 拿 着 它 们 在 内 存 上 咔 咔 咔, 不 同 大 小 的 内 存 就 分 配 好 了, 当 然 别 忘 了 给 它 们 取 个 好 听 的 名 字 在 32 位 的 系 统 上 short 咔 出 来 的 内 存 大 小 是 2 个 byte;int 咔 出 来 的 内 存 大 小 是 4 个 byte;long 咔 出 来 的 内 存 大 小 是 4 个 byte;float 咔 出 来 的 内 存 大 小 是 4 个 byte; double 咔 出 来 的 内 存 大 小 是 8 个 byte;char 咔 出 来 的 内 存 大 小 是 1 个 byte ( 注 意 这 里 指 一 般 情 况, 可 能 不 同 的 平 台 还 会 有 所 不 同, 具 体 平 台 可 以 用 sizeof 关 键 字 测 试 一 下 ) 很 简 单 吧? 咔 咔 咔 很 爽 吧? 是 很 简 单, 也 确 实 很 爽, 但 问 题 就 是 你 咔 出 来 这 么 多 内 存 块, 你 总 不 能 给 他 取 名 字 叫 做 x1,x2,x3,x4,x5 或 者 长 江 1 号, 长 江 2 号 吧 它 们 长 得 这 么 像 ( 不 是 你 家 的 老 大, 老 二, 老 三 ), 过 一 阵 子 你 就 会 忘 了 到 底 哪 个 名 字 和 哪 个 内 存 块 匹 配 了 ( 到 底 谁 嫁 给 谁 了 啊?^_^) 所 以 呢, 给 他 们 取 一 个 好 的 名 字 绝 对 重 要 下 面 我 们 就 来 研 究 研 究 取 什 么 样 的 名 字 好 1.4.2, 变 量 的 命 名 规 则 一 般 规 则 : 规 则 1-1 命 名 应 当 直 观 且 可 以 拼 读, 可 望 文 知 意, 便 于 记 忆 和 阅 读 标 识 符 最 好 采 用 英 文 单 词 或 其 组 合, 不 允 许 使 用 拼 音 程 序 中 的 英 文 单 词 一 般 不 要 太 复 杂, 用 词 应 当 准 确 规 则 1-2 命 名 的 长 度 应 当 符 合 min-length && max-information 原 则 C 是 一 种 简 洁 的 语 言, 命 名 也 应 该 是 简 洁 的 例 如 变 量 名 MaxVal 就 比 MaxValueUntilOverflow 好 用 标 识 符 的 长 度 一 般 不 要 过 长, 较 长 的 单 词 可 通 过 去 掉 元 音 形 成 缩 写 另 外, 英 文 词 尽 量 不 缩 写, 特 别 是 非 常 用 专 业 名 词, 如 果 有 缩 写, 在 同 一 系 统 中 对 同 一 单 词 必 须 使 用 相 同 的 表 示 法, 并 且 注 明 其 意 思 规 则 1-3 当 标 识 符 由 多 个 词 组 成 时, 每 个 词 的 第 一 个 字 母 大 写, 其 余 全 部 小 写 比 如 : int CurrentVal; 这 样 的 名 字 看 起 来 比 较 清 晰, 远 比 一 长 串 字 符 好 得 多 规 则 1-4 尽 量 避 免 名 字 中 出 现 数 字 编 号, 如 Value1,Value2 等, 除 非 逻 辑 上 的 确 需 要 编 号 比 如 驱 动 开 发 时 为 管 脚 命 名, 非 编 号 名 字 反 而 不 好 初 学 者 总 是 喜 欢 用 带 编 号 的 变 量 名 或 函 数 名, 这 样 子 看 上 去 很 简 单 方 便, 但 其 实 是 一 颗 颗 定 时 炸 弹 这 个 习 惯 初 学 者 一 定 要 改 过 来

15 规 则 1-5 对 在 多 个 文 件 之 间 共 同 使 用 的 全 局 变 量 或 函 数 要 加 范 围 限 定 符 ( 建 议 使 用 模 块 名 ( 缩 写 ) 作 为 范 围 限 定 符 ) (GUI_,etc) 标 识 符 的 命 名 规 则 : 规 则 1-6 标 识 符 名 分 为 两 部 分 : 规 范 标 识 符 前 缀 ( 后 缀 )+ 含 义 标 识 非 全 局 变 量 可 以 不 用 使 用 范 围 限 定 符 前 缀 规 则 1-7 作 用 域 前 缀 命 名 规 则 No. 标 识 符 类 型 作 用 域 前 缀 1 GlobalVariable g 2 File Static Variable(native) n 3 Function Static Variable f 4 AutoVariable a 5 GlobalFunction g 6 Static Function n 规 则 1-8 数 据 类 型 前 缀 命 名 规 则 No. Prefix Suffix Data Type Example Remark 1 bt bit Bit btvariable; 2 b boolean boolean bvariable; 3 c char char cvariable; 4 i int int ivariable; 5 s short[int] short[int] svariable; 6 l long[int] long[int] lvariable; 7 u unsigned[int] unsigned[int] uivariable; 8 d double double dvariable; 9 f float float fvariable;

16 10 p pointer void *vpvariable; 指 针 前 缀 11 v void void vvariable; 13 st enum enum A stvariable; 14 st struct struct A stvariable; 15 st union union A stvariable; 16 fp function point void(* fpgetmodefunclist_a[])( void ) 17 _a array of char cvariable_a[table_max]; 当 自 定 义 typedef struct SM_EventOpt 结 构 数 据 类 型 时 使 18 _st _pst typedef enum/struct/u nion unsigned char unsigned int char 用 _st 后 缀 ; 当 自 定 义 结 构 数 据 类 型 为 指 SM_EventOpt_st,*SM_EventOpt_pst; 针 类 型 时 使 用 _pst 后 缀 ; 规 则 1-9 含 义 标 识 命 名 规 则, 变 量 命 名 使 用 名 词 性 词 组, 函 数 命 名 使 用 动 词 性 词 组 例 如 : No 变 量 名 目 标 词 动 词 ( 的 过 去 分 词 ) 状 语 目 的 地 含 义 1 DataGotFromSD Data Got From SD 从 SD 中 取 得 的 数 据 2 DataDeletedFromSD Data Deleted From SD 从 SD 中 删 除 的 数 据 变 量 含 义 标 识 符 构 成 : 目 标 词 + 动 词 ( 的 过 去 分 词 )+ [ 状 语 ]+[ 目 的 地 ]; N o 变 量 名 动 词 ( 一 般 现 时 ) 目 标 词 状 语 目 的 地 含 义 1 GetDataFromSD Get Data From SD 从 SD 中 取 得 数 据 2 DeleteDataFromSD Delete Data From SD 从 SD 中 删 除 数 据

17 函 数 含 义 标 识 符 构 成 : 动 词 ( 一 般 现 时 )+ 目 标 词 +[ 状 语 ]+[ 目 的 地 ]; 规 则 1-10 程 序 中 不 得 出 现 仅 靠 大 小 写 区 分 的 相 似 的 标 识 符 例 如 :int x, X; 变 量 x 与 X 容 易 混 淆 void foo(int x); 函 数 foo 与 FOO 容 易 混 淆 void FOO(float x); 这 里 还 有 一 个 要 特 别 注 意 的 就 是 1( 数 字 1) 和 l( 小 写 字 母 l) 之 间,0( 数 字 0) 和 o ( 小 写 字 母 o) 之 间 的 区 别 这 两 对 真 是 很 难 区 分 的, 我 曾 经 的 一 个 同 事 就 被 这 个 问 题 折 腾 了 一 次 规 则 1-11 一 个 函 数 名 禁 止 被 用 于 其 它 之 处 例 如 : #include "c_standards.h" void foo(int p_1) int x = p_1; void static_p(void) int foo = 1u; 规 则 1-12 所 有 宏 定 义 枚 举 常 数 只 读 变 量 全 用 大 写 字 母 命 名, 用 下 划 线 分 割 单 词 例 如 : const int MAX_LENGTH = 100; // 这 不 是 常 量, 而 是 一 个 只 读 变 量, 具 体 请 往 后 看 #define FILE_PATH /usr/tmp 规 则 1-13 考 虑 到 习 惯 性 问 题, 局 部 变 量 中 可 采 用 通 用 的 命 名 方 式, 仅 限 于 n i j 等 作 为 循 环 变 量 使 用 一 定 不 要 写 出 如 下 这 样 的 代 码 : int p; char i; int c; char * a;

18 一 般 来 说 习 惯 上 用 n,m,i,j,k 等 表 示 int 类 型 的 变 量 ;c,ch 等 表 示 字 符 类 型 变 量 ;a 等 表 示 数 组 ;p 等 表 示 指 针 当 然 这 仅 仅 是 一 般 习 惯, 除 了 i,j,k 等 可 以 用 来 表 示 循 环 变 量 外, 别 的 字 符 变 量 名 尽 量 不 要 使 用 规 则 1-14 定 义 变 量 的 同 时 千 万 千 万 别 忘 了 初 始 化 定 义 变 量 时 编 译 器 并 不 一 定 清 空 了 这 块 内 存, 它 的 值 可 能 是 无 效 的 数 据 这 个 问 题 在 内 存 管 理 那 章 有 非 常 详 细 的 讨 论, 请 参 看 规 则 1-15 不 同 类 型 数 据 之 间 的 运 算 要 注 意 精 度 扩 展 问 题, 一 般 低 精 度 数 据 将 向 高 精 度 数 据 扩 展 1.5, 最 冤 枉 的 关 键 字 ----sizeof 1.5.1, 常 年 被 人 误 认 为 函 数 sizeof 是 关 键 字 不 是 函 数, 其 实 就 算 不 知 道 它 是 否 为 32 个 关 键 字 之 一 时, 我 们 也 可 以 借 助 编 译 器 确 定 它 的 身 份 看 下 面 的 例 子 : int i=0; A),sizeof(int); B),sizeof(i); C),sizeof int; D),sizeof i; 毫 无 疑 问,32 位 系 统 下 A),B) 的 值 为 4 那 C) 的 呢?D) 的 呢? 在 32 位 系 统 下, 通 过 Visual C++6.0 或 任 意 一 编 译 器 调 试, 我 们 发 现 D) 的 结 果 也 为 4 咦?sizeof 后 面 的 括 号 呢? 没 有 括 号 居 然 也 行, 那 想 想, 函 数 名 后 面 没 有 括 号 行 吗? 由 此 轻 易 得 出 sizeof 绝 非 函 数 好, 再 看 C) 编 译 器 怎 么 怎 么 提 示 出 错 呢? 不 是 说 sizeof 是 个 关 键 字, 其 后 面 的 括 号 可 以 没 有 么? 那 你 想 想 sizeof int 表 示 什 么 啊?int 前 面 加 一 个 关 键 字? 类 型 扩 展? 明 显 不 正 确, 我 们 可 以 在 int 前 加 unsigned,const 等 关 键 字 但 不 能 加 sizeof 好, 记 住 :sizeof 在 计 算 变 量 所 占 空 间 大 小 时, 括 号 可 以 省 略, 而 计 算 类 型 ( 模 子 ) 大 小 时 不 能 省 略 一 般 情 况 下, 咱 也 别 偷 这 个 懒, 乖 乖 的 写 上 括 号, 继 续 装 作 一 个 函 数, 做 一 个 披 着 函 数 皮 的 关 键 字 做 我 的 关 键 字, 让 人 家 认 为 是 函 数 去 吧 1.5.2,sizeof(int)*p 表 示 什 么 意 思? sizeof(int)*p 表 示 什 么 意 思? 留 几 个 问 题 ( 讲 解 指 针 与 数 组 时 会 详 细 讲 解 ),32 位 系 统 下 : int *p = NULL; sizeof(p) 的 值 是 多 少? sizeof(*p) 呢?

19 int a[100]; sizeof (a) 的 值 是 多 少? sizeof(a[100]) 呢?// 请 尤 其 注 意 本 例 sizeof(&a) 呢? sizeof(&a[0]) 呢? int b[100]; void fun(int b[100]) sizeof(b);// sizeof (b) 的 值 是 多 少? 1.4,signed unsigned 关 键 字 我 们 知 道 计 算 机 底 层 只 认 识 0 1. 任 何 数 据 到 了 底 层 都 会 变 计 算 转 换 成 0 1. 那 负 数 怎 么 存 储 呢? 肯 定 这 个 - 号 是 无 法 存 入 内 存 的, 怎 么 办? 很 好 办, 做 个 标 记 把 基 本 数 据 类 型 的 最 高 位 腾 出 来, 用 来 存 符 号, 同 时 约 定 如 下 : 最 高 位 如 果 是 1, 表 明 这 个 数 是 负 数, 其 值 为 除 最 高 位 以 外 的 剩 余 位 的 值 添 上 这 个 - 号 ; 如 果 最 高 位 是 0, 表 明 这 个 数 是 正 数, 其 值 为 除 最 高 位 以 外 的 剩 余 位 的 值 这 样 的 话, 一 个 32 位 的 signed int 类 型 整 数 其 值 表 示 法 范 围 为 :- 2 ~ 2-1;8 位 的 7 7 char 类 型 数 其 值 表 示 的 范 围 为 - 2 ~ 2-1 一 个 32 位 的 unsigned int 类 型 整 数 其 值 表 示 法 32 8 范 围 为 :0~ 2-1;8 位 的 char 类 型 数 其 值 表 示 的 范 围 为 0~ 2-1 同 样 我 们 的 signed 关 键 字 也 很 宽 恒 大 量, 你 也 可 以 完 全 当 它 不 存 在, 编 译 器 缺 省 默 认 情 况 下 数 据 为 signed 类 型 的 上 面 的 解 释 很 容 易 理 解, 下 面 就 考 虑 一 下 这 个 问 题 : int main() char a[1000]; int i; for(i=0; i<1000; i++) a[i] = -1-i; printf("%d",strlen(a)); return 0;

20 此 题 看 上 去 真 的 很 简 单, 但 是 却 鲜 有 人 答 对 答 案 是 255 别 惊 讶, 我 们 先 分 析 分 析 for 循 环 内, 当 i 的 值 为 0 时,a[0] 的 值 为 -1 关 键 就 是 -1 在 内 存 里 面 如 何 存 储 我 们 知 道 在 计 算 机 系 统 中, 数 值 一 律 用 补 码 来 表 示 ( 存 储 ) 主 要 原 因 是 使 用 补 码, 可 以 将 符 号 位 和 其 它 位 统 一 处 理 ; 同 时, 减 法 也 可 按 加 法 来 处 理 另 外, 两 个 用 补 码 表 示 的 数 相 加 时, 如 果 最 高 位 ( 符 号 位 ) 有 进 位, 则 进 位 被 舍 弃 正 数 的 补 码 与 其 原 码 一 致 ; 负 数 的 补 码 : 符 号 位 为 1, 其 余 位 为 该 数 绝 对 值 的 原 码 按 位 取 反, 然 后 整 个 数 加 1 按 照 负 数 补 码 的 规 则, 可 以 知 道 -1 的 补 码 为 0xff,-2 的 补 码 为 0xfe 当 i 的 值 为 127 时,a[127] 的 值 为 -128, 而 -128 是 char 类 型 数 据 能 表 示 的 最 小 的 负 数 当 i 继 续 增 加,a[128] 的 值 肯 定 不 能 是 -129 因 为 这 时 候 发 生 了 溢 出,-129 需 要 9 位 才 能 存 储 下 来, 而 char 类 型 数 据 只 有 8 位, 所 以 最 高 位 被 丢 弃 剩 下 的 8 位 是 原 来 9 位 补 码 的 低 8 位 的 值, 即 0x7f 当 i 继 续 增 加 到 255 的 时 候,-256 的 补 码 的 低 8 位 为 0 然 后 当 i 增 加 到 256 时,-257 的 补 码 的 低 8 位 全 为 1, 即 低 八 位 的 补 码 为 0xff, 如 此 又 开 始 一 轮 新 的 循 环 按 照 上 面 的 分 析,a[0] 到 a[254] 里 面 的 值 都 不 为 0, 而 a[255] 的 值 为 0 strlen 函 数 是 计 算 字 符 串 长 度 的, 并 不 包 含 字 符 串 最 后 的 \0 而 判 断 一 个 字 符 串 是 否 结 束 的 标 志 就 是 看 是 否 遇 到 \0 如 果 遇 到 \0, 则 认 为 本 字 符 串 结 束 分 析 到 这 里,strlen(a) 的 值 为 255 应 该 完 全 能 理 解 了 这 个 问 题 的 关 键 就 是 要 明 白 char 类 型 默 认 情 况 下 是 有 符 号 的, 其 表 示 的 值 的 范 围 为 [-128,127], 超 出 这 个 范 围 的 值 会 产 生 溢 出 另 外 还 要 清 楚 的 就 是 负 数 的 补 码 怎 么 表 示 弄 明 白 了 这 两 点, 这 个 问 题 其 实 就 很 简 单 了 留 三 个 问 题 : 1), 按 照 我 们 上 面 的 解 释, 那 -0 和 +0 在 内 存 里 面 分 别 怎 么 存 储? 2),int i = -20; unsigned j = 10; i+j 的 值 为 多 少? 为 什 么? 3), 下 面 的 代 码 有 什 么 问 题? unsigned i ; for (i=9;i>=0;i--) printf("%u\n",i); 1.6,if else 组 合 if 语 句 很 简 单 吧 嗯, 的 确 很 简 单 那 我 们 就 简 单 的 看 下 面 几 个 简 单 的 问 题 : 1.6.1,bool 变 量 与 零 值 进 行 比 较 bool 变 量 与 零 值 进 行 比 较 的 if 语 句 怎 么 写?

21 bool btestflag = FALSE;// 想 想 为 什 么 一 般 初 始 化 为 FALSE 比 较 好? A), if(btestflag == 0); if(btestflag == 1); B), if(btestflag == TRUE); C), if(btestflag); if(btestflag == FLASE); if(!btestflag); 哪 一 组 或 是 那 些 组 正 确 呢? 我 们 来 分 析 分 析 : A) 写 法 :btestflag 是 什 么? 整 型 变 量? 如 果 要 不 是 这 个 名 字 遵 照 了 前 面 的 命 名 规 范, 肯 怕 很 容 易 让 人 误 会 成 整 型 变 量 所 以 这 种 写 法 不 好 B) 写 法 :FLASE 的 值 大 家 都 知 道, 在 编 译 器 里 被 定 义 为 0; 但 TRUE 的 值 呢? 都 是 1 吗? 很 不 幸, 不 都 是 1 Visual C++ 定 义 为 1, 而 它 的 同 胞 兄 弟 Visual Basic 就 把 TRUE 定 义 为 -1. 那 很 显 然, 这 种 写 法 也 不 好 大 家 都 知 道 if 语 句 是 靠 其 后 面 的 括 号 里 的 表 达 式 的 值 来 进 行 分 支 跳 转 的 表 达 式 如 果 为 真, 则 执 行 if 语 句 后 面 紧 跟 的 代 码 ; 否 则 不 执 行 那 显 然, 本 组 的 写 法 很 好, 既 不 会 引 起 误 会, 也 不 会 由 于 TRUE 或 FLASE 的 不 同 定 义 值 而 出 错 记 住 : 以 后 写 代 码 就 得 这 样 写 1.6.2, float 变 量 与 零 值 进 行 比 较 float 变 量 与 零 值 进 行 比 较 的 if 语 句 怎 么 写? float ftestval = 0.0; A), if(ftestval == 0.0); if(ftestval!= 0.0); B), if((ftestval >= -EPSINON) && (ftestval <= EPSINON)); //EPSINON 为 定 义 好 的 精 度 哪 一 组 或 是 那 些 组 正 确 呢? 我 们 来 分 析 分 析 : float 和 double 类 型 的 数 据 都 是 有 精 度 限 制 的, 这 样 直 接 拿 来 与 0.0 比, 能 正 确 吗? 明 显 不 能, 看 例 子 : 的 值 四 舍 五 入 精 确 到 小 数 点 后 10 位 为 : , 你 拿 它 减 去 然 后 再 四 舍 五 入 得 到 的 结 果 是 多 少? 你 能 说 前 后 两 个 值 一 样 吗? EPSINON 为 定 义 好 的 精 度, 如 果 一 个 数 落 在 [0.0-EPSINON,0.0+EPSINON] 这 个 闭 区 间 内, 我 们 认 为 在 某 个 精 度 内 它 的 值 与 零 值 相 等 ; 否 则 不 相 等 扩 展 一 下, 把 0.0 替 换 为 你 想 比 较 的 任 何 一 个 浮 点 数, 那 我 们 就 可 以 比 较 任 意 两 个 浮 点 数 的 大 小 了, 当 然 是 在 某 个 精 度 内 同 样 的 也 不 要 在 很 大 的 浮 点 数 和 很 小 的 浮 点 数 之 间 进 行 运 算, 比 如 : 这 样 计 算 后 的 结 果 可 能 会 让 你 大 吃 一 惊 1.6.3, 指 针 变 量 与 零 值 进 行 比 较 指 针 变 量 与 零 值 进 行 比 较 的 if 语 句 怎 么 写?

22 int*p=null;// 定 义 指 针 一 定 要 同 时 初 始 化, 指 针 与 数 组 那 章 会 详 细 讲 解 A), if(p == 0); if(p!= 0); B), if(p); if(!p); C), if(null == p); if(null!= p); 哪 一 组 或 是 那 些 组 正 确 呢? 我 们 来 分 析 分 析 : A) 写 法 :p 是 整 型 变 量? 容 易 引 起 误 会, 不 好 尽 管 NULL 的 值 和 0 一 样, 但 意 义 不 同 B) 写 法 :p 是 bool 型 变 量? 容 易 引 起 误 会, 不 好 C) 写 法 : 这 个 写 法 才 是 正 确 的, 但 样 子 比 较 古 怪 为 什 么 要 这 么 写 呢? 是 怕 漏 写 一 个 = 号 :if(p = NULL), 这 个 表 达 式 编 译 器 当 然 会 认 为 是 正 确 的, 但 却 不 是 你 要 表 达 的 意 思 所 以, 非 常 推 荐 这 种 写 法 1.6.4,else 到 底 与 哪 个 if 配 对 呢? else 常 常 与 if 语 句 配 对, 但 要 注 意 书 写 规 范, 看 下 面 例 子 : if(0==x) if(0==y) error(); else //program code 这 个 else 到 底 与 谁 匹 配 呢? 让 人 迷 糊, 尤 其 是 初 学 者 还 好,C 语 言 有 这 样 的 规 定 :else 始 终 与 同 一 括 号 内 最 近 的 未 匹 配 的 if 语 句 结 合 虽 然 老 手 可 以 区 分 出 来, 但 这 样 的 代 码 谁 都 会 头 疼 的, 任 何 时 候 都 别 偷 这 种 懒 关 于 程 序 中 的 分 界 符 和, 建 议 如 下 : 建 议 1-16 程 序 中 的 分 界 符 和 对 齐 风 格 如 下 : 注 意 下 表 中 代 码 的 缩 进 一 般 为 4 个 字 符, 但 不 要 使 用 Tab 键, 因 为 不 同 的 编 辑 器 Tab 键 定 义 的 空 格 数 量 不 一 样, 别 的 编 辑 器 打 开 Tab 键 缩 进 的 代 码 可 能 会 一 片 混 乱 提 倡 的 的 风 格 void Function(int x) //program code 不 提 倡 的 风 格 void Function(int x) //program code if (condition) //program code if (condition) //program code else //program code

23 else 或 : //program code if (condition) //program code else //program code 或 : if (width < height) dosomething(); for (initialization; condition; update) //program code for (initialization;condition; update) //program code while (condition) //program code while (condition) //program code do do //program code //program code while (condition); while (condition); 1.6.5,if 语 句 后 面 的 分 号 关 于 if-else 语 句 还 有 一 个 容 易 出 错 的 地 方 就 是 与 空 语 句 的 连 用 看 下 面 的 例 子 : if(null!= p) ; fun(); 这 里 的 fun() 函 数 并 不 是 在 NULL!= p 的 时 候 被 调 用, 而 是 任 何 时 候 都 会 被 调 用 问 题 就 出 在 if 语 句 后 面 的 分 号 上 在 C 语 言 中, 分 号 预 示 着 一 条 语 句 的 结 尾, 但 是 并 不 是 每 条 C 语 言 语 句 都 需 要 分 号 作 为 结 束 标 志 if 语 句 的 后 面 并 不 需 要 分 号, 但 如 果 你 不 小 心 写 了 个 分 号, 编 译 器 并 不 会 提 示 出 错 因 为 编 译 器 会 把 这 个 分 号 解 析 成 一 条 空 语 句 也 就 是 上 面 的 代 码 实 际 等 效 于 : if(null!= p)

24 ; fun(); 这 是 初 学 者 很 容 易 犯 的 错 误, 往 往 不 小 心 多 写 了 个 分 号, 导 致 结 果 与 预 想 的 相 差 很 远 所 以 建 议 在 真 正 需 要 用 空 语 句 时 写 成 这 样 : NULL; 而 不 是 单 用 一 个 分 号 这 就 好 比 汇 编 语 言 里 面 的 空 指 令, 比 如 ARM 指 令 中 的 NOP 指 令 这 样 做 可 以 明 显 的 区 分 真 正 必 须 的 空 语 句 和 不 小 心 多 写 的 分 号 1.6.6, 使 用 if 语 句 的 其 他 注 意 事 项 规 则 1-17 先 处 理 正 常 情 况, 再 处 理 异 常 情 况 在 编 写 代 码 是, 要 使 得 正 常 情 况 的 执 行 代 码 清 晰, 确 认 那 些 不 常 发 生 的 异 常 情 况 处 理 代 码 不 会 遮 掩 正 常 的 执 行 路 径 这 样 对 于 代 码 的 可 读 性 和 性 能 都 很 重 要 因 为,if 语 句 总 是 需 要 做 判 断, 而 正 常 情 况 一 般 比 异 常 情 况 发 生 的 概 率 更 大 ( 否 则 就 应 该 把 异 常 正 常 调 过 来 了 ), 如 果 把 执 行 概 率 更 大 的 代 码 放 到 后 面, 也 就 意 味 着 if 语 句 将 进 行 多 次 无 谓 的 比 较 另 外, 非 常 重 要 的 一 点 是, 把 正 常 情 况 的 处 理 放 在 if 后 面, 而 不 要 放 在 else 后 面 当 然 这 也 符 合 把 正 常 情 况 的 处 理 放 在 前 面 的 要 求 规 则 1-18 确 保 if 和 else 子 句 没 有 弄 反 这 一 点 初 学 者 也 容 易 弄 错, 往 往 把 本 应 该 放 在 if 语 句 后 面 的 代 码 和 本 应 该 放 在 else 语 句 后 面 的 代 码 弄 反 了 1.7,switch case 组 合 既 然 有 了 if else 组 合 为 什 么 还 需 要 switch case 组 合 呢? 1.7.1, 不 要 拿 青 龙 偃 月 刀 去 削 苹 果 那 你 既 然 有 了 菜 刀 为 什 么 还 需 要 水 果 刀 呢? 你 总 不 能 扛 着 云 长 的 青 龙 偃 月 刀 ( 又 名 冷 艳 锯 ) 去 削 苹 果 吧 如 果 你 真 能 做 到, 关 二 爷 也 会 佩 服 你 的 ^_^ if else 一 般 表 示 两 个 分 支 或 是 嵌 套 表 示 少 量 的 分 支, 但 如 果 分 支 很 多 的 话 还 是 用 switch case 组 合 吧 其 基 本 格 式 为 : switch(variable) case Value1: //program code

25 break; case Value2: //program code break; case Value3: //program code break; default: break; 很 简 单, 但 有 两 个 规 则 : 规 则 1-19 每 个 case 语 句 的 结 尾 绝 对 不 要 忘 了 加 break, 否 则 将 导 致 多 个 分 支 重 叠 ( 除 非 有 意 使 多 个 分 支 重 叠 ) 规 则 1-20 最 后 必 须 使 用 default 分 支 即 使 程 序 真 的 不 需 要 default 处 理, 也 应 该 保 留 语 句 : default : break; 这 样 做 并 非 画 蛇 添 足, 可 以 避 免 让 人 误 以 为 你 忘 了 default 处 理 1.7.2,case 关 键 字 后 面 的 值 有 什 么 要 求 吗? 好, 再 问 问 : 真 的 就 这 么 简 单 吗? 看 看 下 面 的 问 题 : Value1 的 值 为 0.1 行 吗?-0.1 呢?-1 呢? 呢? 1+2 呢?3/2 呢? A 呢? A 呢? 变 量 i( 假 设 i 已 经 被 初 始 化 ) 呢?NULL 呢? 等 等 这 些 情 形 希 望 你 亲 自 上 机 调 试 一 下, 看 看 到 底 哪 些 行, 哪 些 不 行 记 住 :case 后 面 只 能 是 整 型 或 字 符 型 的 常 量 或 常 量 表 达 式 ( 想 想 字 符 型 数 据 在 内 存 里 是 怎 么 存 的 ) 1.7.3,case 语 句 的 排 列 顺 序 似 乎 从 来 没 有 人 考 虑 过 这 个 问 题, 也 有 很 多 人 认 为 case 语 句 的 顺 序 无 所 谓 但 事 实 却 不 是 如 此 如 果 case 语 句 很 少, 你 也 许 可 以 忽 略 这 点, 但 是 如 果 case 语 句 非 常 多, 那 就 不 得 不 好 好 考 虑 这 个 问 题 了 比 如 你 写 的 是 某 个 驱 动 程 序, 也 许 会 经 常 遇 到 几 十 个 case 语 句 的 情 况 一 般 来 说, 我 们 可 以 遵 循 下 面 的 规 则 :

26 规 则 1-21 按 字 母 或 数 字 顺 序 排 列 各 条 case 语 句 如 果 所 有 的 case 语 句 没 有 明 显 的 重 要 性 差 别, 那 就 按 A-B-C 或 等 顺 序 排 列 case 语 句 这 样 做 的 话, 你 可 以 很 容 易 的 找 到 某 条 case 语 句 比 如 : switch(variable) case A: //program code break; case B: //program code break; case C: //program code break; default: break; 规 则 1-22 把 正 常 情 况 放 在 前 面, 而 把 异 常 情 况 放 在 后 面 如 果 有 多 个 正 常 情 况 和 异 常 情 况, 把 正 常 情 况 放 在 前 面, 并 做 好 注 释 ; 把 异 常 情 况 放 在 后 面, 同 样 要 做 注 释 比 如 : switch(variable) /////////////////////////////////////////////////////////////////////////////////// // 正 常 情 况 开 始 case A: //program code break; case B: //program code break; // 正 常 情 况 结 束 //////////////////////////////////////////////////////////////////////////////////////

27 // 异 常 情 况 开 始 case -1: //program code break; // 异 常 情 况 结 束 ////////////////////////////////////////////////////////////////////////////////////// default: break; 规 则 1-23 按 执 行 频 率 排 列 case 语 句 把 最 常 执 行 的 情 况 放 在 前 面, 而 把 最 不 常 执 行 的 情 况 放 在 后 面 最 常 执 行 的 代 码 可 能 也 是 调 试 的 时 候 要 单 步 执 行 的 最 多 的 代 码 如 果 放 在 后 面 的 话, 找 起 来 可 能 会 比 较 困 难, 而 放 在 前 面 的 话, 可 以 很 快 的 找 到 1.7.4, 使 用 case 语 句 的 其 他 注 意 事 项 规 则 1-24 简 化 每 种 情 况 对 应 的 操 作 使 得 与 每 种 情 况 相 关 的 代 码 尽 可 能 的 精 炼 case 语 句 后 面 的 代 码 越 精 炼,case 语 句 的 结 果 就 会 越 清 晰 你 想 想, 如 果 case 语 句 后 面 的 代 码 整 个 屏 幕 都 放 不 下, 这 样 的 代 码 谁 也 难 看 得 很 清 晰 吧 如 果 某 个 case 语 句 确 实 需 要 这 么 多 的 代 码 来 执 行 某 个 操 作, 那 可 以 把 这 些 操 作 写 成 一 个 或 几 个 子 程 序, 然 后 在 case 语 句 后 面 调 用 这 些 子 程 序 就 ok 了 一 般 来 说 case 语 句 后 面 的 代 码 尽 量 不 要 超 过 20 行 规 则 1-25 不 要 为 了 使 用 case 语 句 而 刻 意 制 造 一 个 变 量 case 语 句 应 该 用 于 处 理 简 单 的, 容 易 分 类 的 数 据 如 果 你 的 数 据 并 不 简 单, 那 可 能 使 用 ifelse if 的 组 合 更 好 一 些 为 了 使 用 case 而 刻 意 构 造 出 来 的 变 量 很 容 易 把 人 搞 糊 涂, 应 该 避 免 这 种 变 量 比 如 : char action = a[0]; switch (action) case c : fun1(); break; case d : break; default:

28 break; 这 里 控 制 case 语 句 的 变 量 是 action 而 action 的 值 是 取 字 符 数 组 a 的 一 个 字 符 但 是 这 种 方 式 可 能 带 来 一 些 隐 含 的 错 误 一 般 而 言, 当 你 为 了 使 用 case 语 句 而 刻 意 去 造 出 一 个 变 量 时, 真 正 的 数 据 可 能 不 会 按 照 你 所 希 望 的 方 式 映 射 到 case 语 句 里 在 这 个 例 子 中, 如 果 用 户 输 入 字 符 数 组 a 里 面 存 的 是 const 这 个 字 符 串, 那 么 case 语 句 会 匹 配 到 第 一 个 case 上, 并 调 用 fun1() 函 数 然 而 如 果 这 个 数 组 里 存 的 是 别 的 以 字 符 c 开 头 的 任 何 字 符 串 ( 比 如 : col, can ),case 分 支 同 样 会 匹 配 到 第 一 个 case 上 但 是 这 也 许 并 不 是 你 想 要 的 结 果, 这 个 隐 含 的 错 误 往 往 使 人 抓 狂 如 果 这 样 的 话 还 不 如 使 用 if-else if 组 合 比 如 : if(0 == strcmp( const,a)) fun1(); else if 规 则 1-26 把 default 子 句 只 用 于 检 查 真 正 的 默 认 情 况 有 时 候, 你 只 剩 下 了 最 后 一 种 情 况 需 要 处 理, 于 是 就 决 定 把 这 种 情 况 用 default 子 句 来 处 理 这 样 也 许 会 让 你 偷 懒 少 敲 几 个 字 符, 但 是 这 却 很 不 明 智 这 样 将 失 去 case 语 句 的 标 号 所 提 供 的 自 说 明 功 能, 而 且 也 丧 失 了 使 用 default 子 句 处 理 错 误 情 况 的 能 力 所 以, 奉 劝 你 不 要 偷 懒, 老 老 实 实 的 把 每 一 种 情 况 都 用 case 语 句 来 完 成, 而 把 真 正 的 默 认 情 况 的 处 理 交 给 default 子 句 1.8,do while for 关 键 字 C 语 言 中 循 环 语 句 有 三 种 :while 循 环 do-while 循 环 for 循 环 while 循 环 : 先 判 断 while 后 面 括 号 里 的 值, 如 果 为 真 则 执 行 其 后 面 的 代 码 ; 否 则 不 执 行 while(1) 表 示 死 循 环 死 循 环 有 没 有 用 呢? 看 下 面 例 子 : 比 如 你 开 发 一 个 系 统 要 日 夜 不 停 的 运 行, 但 是 只 有 操 作 员 输 入 某 个 特 定 的 字 符 # 才 可 以 停 下 来 while(1) if( # == GetInputChar()) break;

29 1.8.1,break 与 continue 的 区 别 break 关 键 字 很 重 要, 表 示 终 止 本 层 循 环 现 在 这 个 例 子 只 有 一 层 循 环, 当 代 码 执 行 到 break 时, 循 环 便 终 止 如 果 把 break 换 成 continue 会 是 什 么 样 子 呢?continue 表 示 终 止 本 次 ( 本 轮 ) 循 环 当 代 码 执 行 到 continue 时, 本 轮 循 环 终 止, 进 入 下 一 轮 循 环 while(1) 也 有 写 成 while(true) 或 者 while(1==1) 或 者 while((bool) 1) 等 形 式 的, 效 果 一 样 do-while 循 环 : 先 执 行 do 后 面 的 代 码, 然 后 再 判 断 while 后 面 括 号 里 的 值, 如 果 为 真, 循 环 开 始 ; 否 则, 循 环 不 开 始 其 用 法 与 while 循 环 没 有 区 别, 但 相 对 较 少 用 for 循 环 :for 循 环 可 以 很 容 易 的 控 制 循 环 次 数, 多 用 于 事 先 知 道 循 环 次 数 的 情 况 下 留 一 个 问 题 : 在 switch case 语 句 中 能 否 使 用 continue 关 键 字? 为 什 么? 1.8.2, 循 环 语 句 的 注 意 点 建 议 1-27 在 多 重 循 环 中, 如 果 有 可 能, 应 当 将 最 长 的 循 环 放 在 最 内 层, 最 短 的 循 环 放 在 最 外 层, 以 减 少 CPU 跨 切 循 环 层 的 次 数 例 如 : 长 循 环 在 最 内 层, 效 率 高 for (col=0; col<5; col++ ) for (row=0; row<100; row++) sum = sum + a[row][col]; 长 循 环 在 最 外 层, 效 率 低 for (row=0; row<100; row++) for ( col=0; col<5; col++ ) sum = sum + a[row][col]; 建 议 1-28 建 议 for 语 句 的 循 环 控 制 变 量 的 取 值 采 用 半 开 半 闭 区 间 写 法 半 开 半 闭 区 间 写 法 和 闭 区 间 写 法 虽 然 功 能 是 相 同, 但 相 比 之 下, 半 开 半 闭 区 间 写 法 写 法 更 加 直 观 半 开 半 闭 区 间 写 法 for(n=0;n<10;n++) 闭 区 间 写 法 for(n=0;n<=9;n++)

30 规 则 1-29 不 能 在 for 循 环 体 内 修 改 循 环 变 量, 防 止 循 环 失 控 for (n = 0; n < 10; n++) n=8;// 不 可, 很 可 能 违 背 了 你 的 原 意 规 则 1-30 循 环 要 尽 可 能 的 短, 要 使 代 码 清 晰, 一 目 了 然 如 果 你 写 的 一 个 循 环 的 代 码 超 过 一 显 示 屏, 那 会 让 读 代 码 的 人 发 狂 的 解 决 的 办 法 由 两 个 : 第 一, 重 新 设 计 这 个 循 环, 确 认 是 否 这 些 操 作 都 必 须 放 在 这 个 循 环 里 ; 第 二, 将 这 些 代 码 改 写 成 一 个 子 函 数, 循 环 中 只 调 用 这 个 子 函 数 即 可 一 般 来 说 循 环 内 的 代 码 不 要 超 过 20 行 规 则 1-31 把 循 环 嵌 套 控 制 在 3 层 以 内 国 外 有 研 究 数 据 表 明, 当 循 环 嵌 套 超 过 3 层, 程 序 员 对 循 环 的 理 解 能 力 会 极 大 的 降 低 如 果 你 的 循 环 嵌 套 超 过 3 层, 建 议 你 重 新 设 计 循 环 或 是 将 循 环 内 的 代 码 改 写 成 一 个 字 函 数 1.9,goto 关 键 字 一 般 来 说, 编 码 的 水 平 与 goto 语 句 使 用 的 次 数 成 反 比 有 的 人 主 张 慎 用 但 不 禁 用 goto 语 句, 但 我 主 张 禁 用 关 于 goto 语 句 的 更 多 讨 论 可 以 参 看 Steve McConnell 的 名 著 Code Complete. Second Edition 规 则 1-32 禁 用 goto 语 句 自 从 提 倡 结 构 化 设 计 以 来,goto 就 成 了 有 争 议 的 语 句 首 先, 由 于 goto 语 句 可 以 灵 活 跳 转, 如 果 不 加 限 制, 它 的 确 会 破 坏 结 构 化 设 计 风 格 ; 其 次,goto 语 句 经 常 带 来 错 误 或 隐 患 它 可 能 跳 过 了 变 量 的 初 始 化 重 要 的 计 算 等 语 句, 例 如 : struct student *p = NULL; goto state; p = (struct student *)malloc( ); // 被 goto 跳 过, 没 有 初 始 化

31 state: // 使 用 p 指 向 的 内 存 里 的 值 的 代 码 如 果 编 译 器 不 能 发 觉 此 类 错 误, 每 用 一 次 goto 语 句 都 可 能 留 下 隐 患 1.10,void 关 键 字 void 有 什 么 好 讲 的 呢? 如 果 你 认 为 没 有, 那 就 没 有 ; 但 如 果 你 认 为 有, 那 就 真 的 有 有 点 像 色 即 是 空, 空 即 是 色 ,void a? void 的 字 面 意 思 是 空 类 型,void * 则 为 空 类 型 指 针,void * 可 以 指 向 任 何 类 型 的 数 据 void 几 乎 只 有 注 释 和 限 制 程 序 的 作 用, 因 为 从 来 没 有 人 会 定 义 一 个 void 变 量, 看 看 下 面 的 例 子 : void a; Visual C++6.0 上, 这 行 语 句 编 译 时 会 出 错, 提 示 illegal use of type 'void' 不 过, 即 使 void a 的 编 译 不 会 出 错, 它 也 没 有 任 何 实 际 意 义 void 真 正 发 挥 的 作 用 在 于 : (1) 对 函 数 返 回 的 限 定 ; (2) 对 函 数 参 数 的 限 定 众 所 周 知, 如 果 指 针 p1 和 p2 的 类 型 相 同, 那 么 我 们 可 以 直 接 在 p1 和 p2 间 互 相 赋 值 ; 如 果 p1 和 p2 指 向 不 同 的 数 据 类 型, 则 必 须 使 用 强 制 类 型 转 换 运 算 符 把 赋 值 运 算 符 右 边 的 指 针 类 型 转 换 为 左 边 指 针 的 类 型 例 如 : float *p1; int *p2; p1 = p2; 其 中 p1 = p2 语 句 会 编 译 出 错, 提 示 '=' : cannot convert from 'int *' to 'float *', 必 须 改 为 : p1 = (float *)p2; 而 void * 则 不 同, 任 何 类 型 的 指 针 都 可 以 直 接 赋 值 给 它, 无 需 进 行 强 制 类 型 转 换 : void *p1; int *p2; p1 = p2; 但 这 并 不 意 味 着,void * 也 可 以 无 需 强 制 类 型 转 换 地 赋 给 其 它 类 型 的 指 针 因 为 空 类 型 可 以 包 容 有 类 型, 而 有 类 型 则 不 能 包 容 空 类 型 比 如, 我 们 可 以 说 男 人 和 女 人 都 是 人, 但 不 能 说 人 是 男 人 或 者 人 是 女 人 下 面 的 语 句 编 译 出 错 :

32 void *p1; int *p2; p2 = p1; 提 示 '=' : cannot convert from 'void *' to 'int *' ,void 修 饰 函 数 返 回 值 和 参 数 规 则 1-33 如 果 函 数 没 有 返 回 值, 那 么 应 声 明 为 void 类 型 在 C 语 言 中, 凡 不 加 返 回 值 类 型 限 定 的 函 数, 就 会 被 编 译 器 作 为 返 回 整 型 值 处 理 但 是 许 多 程 序 员 却 误 以 为 其 为 void 类 型 例 如 : add ( int a, int b ) return a + b; int main(int argc, char* argv[]) // 甚 至 很 多 人 以 为 main 函 数 无 返 回 值 // 或 是 为 void 型 的 printf("2+3=%d",add(2,3)); 程 序 运 行 的 结 果 为 输 出 : 2+3=5 这 说 明 不 加 返 回 值 说 明 的 函 数 的 确 为 int 函 数 因 此, 为 了 避 免 混 乱, 我 们 在 编 写 C 程 序 时, 对 于 任 何 函 数 都 必 须 一 个 不 漏 地 指 定 其 类 型 如 果 函 数 没 有 返 回 值, 一 定 要 声 明 为 void 类 型 这 既 是 程 序 良 好 可 读 性 的 需 要, 也 是 编 程 规 范 性 的 要 求 另 外, 加 上 void 类 型 声 明 后, 也 可 以 发 挥 代 码 的 自 注 释 作 用 所 谓 的 代 码 的 自 注 释 即 代 码 能 自 己 注 释 自 己 规 则 1-34 如 果 函 数 无 参 数, 那 么 应 声 明 其 参 数 为 void 在 C++ 语 言 中 声 明 一 个 这 样 的 函 数 : int function(void) return 1; 则 进 行 下 面 的 调 用 是 不 合 法 的 :function(2); 因 为 在 C++ 中, 函 数 参 数 为 void 的 意 思 是 这 个 函 数 不 接 受 任 何 参 数 但 是 在 Turbo C 2.0 中 编 译 : #include "stdio.h" fun() return 1; main() printf("%d",fun(2)); getchar();

33 编 译 正 确 且 输 出 1, 这 说 明, 在 C 语 言 中, 可 以 给 无 参 数 的 函 数 传 送 任 意 类 型 的 参 数, 但 是 在 C++ 编 译 器 中 编 译 同 样 的 代 码 则 会 出 错 在 C++ 中, 不 能 向 无 参 数 的 函 数 传 送 任 何 参 数, 出 错 提 示 'fun' : function does not take 1 parameters 所 以, 无 论 在 C 还 是 C++ 中, 若 函 数 不 接 受 任 何 参 数, 一 定 要 指 明 参 数 为 void ,void 指 针 规 则 1-35 千 万 小 心 又 小 心 使 用 void 指 针 类 型 按 照 ANSI(American National Standards Institute) 标 准, 不 能 对 void 指 针 进 行 算 法 操 作, 即 下 列 操 作 都 是 不 合 法 的 : void * pvoid; pvoid++; //ANSI: 错 误 pvoid += 1; //ANSI: 错 误 ANSI 标 准 之 所 以 这 样 认 定, 是 因 为 它 坚 持 : 进 行 算 法 操 作 的 指 针 必 须 是 确 定 知 道 其 指 向 数 据 类 型 大 小 的 也 就 是 说 必 须 知 道 内 存 目 的 地 址 的 确 切 值 例 如 : int *pint; pint++; //ANSI: 正 确 但 是 大 名 鼎 鼎 的 GNU(GNU's Not Unix 的 递 归 缩 写 ) 则 不 这 么 认 定, 它 指 定 void * 的 算 法 操 作 与 char * 一 致 因 此 下 列 语 句 在 GNU 编 译 器 中 皆 正 确 : pvoid++; //GNU: 正 确 pvoid += 1; //GNU: 正 确 在 实 际 的 程 序 设 计 中, 为 符 合 ANSI 标 准, 并 提 高 程 序 的 可 移 植 性, 我 们 可 以 这 样 编 写 实 现 同 样 功 能 的 代 码 : void * pvoid; (char *)pvoid++; //ANSI: 正 确 ;GNU: 正 确 (char *)pvoid += 1; //ANSI: 错 误 ;GNU: 正 确 GNU 和 ANSI 还 有 一 些 区 别, 总 体 而 言,GNU 较 ANSI 更 开 放, 提 供 了 对 更 多 语 法 的 支 持 但 是 我 们 在 真 实 设 计 时, 还 是 应 该 尽 可 能 地 符 合 ANSI 标 准 规 则 1-36 如 果 函 数 的 参 数 可 以 是 任 意 类 型 指 针, 那 么 应 声 明 其 参 数 为 void * 典 型 的 如 内 存 操 作 函 数 memcpy 和 memset 的 函 数 原 型 分 别 为 : void * memcpy(void *dest, const void *src, size_t len); void * memset ( void * buffer, int c, size_t num ); 这 样, 任 何 类 型 的 指 针 都 可 以 传 入 memcpy 和 memset 中, 这 也 真 实 地 体 现 了 内 存 操 作 函 数 的 意 义, 因 为 它 操 作 的 对 象 仅 仅 是 一 片 内 存, 而 不 论 这 片 内 存 是 什 么 类 型 如 果 memcpy 和 memset 的 参 数 类 型 不 是 void *, 而 是 char *, 那 才 叫 真 的 奇 怪 了! 这 样 的 memcpy 和 memset 明 显 不 是 一 个 纯 粹 的, 脱 离 低 级 趣 味 的 函 数! 下 面 的 代 码 执 行 正 确 : 例 子 :memset 接 受 任 意 类 型 指 针 int IntArray_a[100]; memset (IntArray_a, 0, 100*sizeof(int) ); // 将 IntArray_a 清 0 例 子 :memcpy 接 受 任 意 类 型 指 针 int destintarray_a[100], srcintarray_a[100];

34 // 将 srcintarray_a 拷 贝 给 destintarray_a memcpy (destintarray_a, srcintarray_a, 100*sizeof(int) ); 有 趣 的 是,memcpy 和 memset 函 数 返 回 的 也 是 void * 类 型, 标 准 库 函 数 的 编 写 者 都 不 是 一 般 人 ,void 不 能 代 表 一 个 真 实 的 变 量 规 则 1-37 void 不 能 代 表 一 个 真 实 的 变 量 因 为 定 义 变 量 时 必 须 分 配 内 存 空 间, 定 义 void 类 型 变 量, 编 译 器 到 底 分 配 多 大 的 内 存 呢 下 面 代 码 都 企 图 让 void 代 表 一 个 真 实 的 变 量, 因 此 都 是 错 误 的 代 码 : void a; // 错 误 function(void a); // 错 误 void 体 现 了 一 种 抽 象, 这 个 世 界 上 的 变 量 都 是 有 类 型 的, 譬 如 一 个 人 不 是 男 人 就 是 女 人 ( 人 妖 不 算 ) void 的 出 现 只 是 为 了 一 种 抽 象 的 需 要, 如 果 你 正 确 地 理 解 了 面 向 对 象 中 抽 象 基 类 的 概 念, 也 很 容 易 理 解 void 数 据 类 型 正 如 不 能 给 抽 象 基 类 定 义 一 个 实 例, 我 们 也 不 能 定 义 一 个 void( 让 我 们 类 比 的 称 void 为 抽 象 数 据 类 型 ) 变 量 void 简 单 吧? 到 底 是 色 还 是 空 呢? 1.10,return 关 键 字 return 用 来 终 止 一 个 函 数 并 返 回 其 后 面 跟 着 的 值 return (Val);// 此 括 号 可 以 省 略 但 一 般 不 省 略, 尤 其 在 返 回 一 个 表 达 式 的 值 时 return 可 以 返 回 些 什 么 东 西 呢? 看 下 面 例 子 : char * Func(void) char str[30]; return str; str 属 于 局 部 变 量, 位 于 栈 内 存 中, 在 Func 结 束 的 时 候 被 释 放, 所 以 返 回 str 将 导 致 错 误 规 则 1-38 return 语 句 不 可 返 回 指 向 栈 内 存 的 指 针, 因 为 该 内 存 在 函 数 体 结 束 时 被 自 动 销 毁 留 个 问 题 : return ; 这 个 语 句 有 问 题 吗? 如 果 没 有 问 题, 那 返 回 的 是 什 么?

35 1.11,const 关 键 字 也 许 该 被 替 换 为 readolny const 是 constant 的 缩 写, 是 恒 定 不 变 的 意 思, 也 翻 译 为 常 量 常 数 等 很 不 幸, 正 是 因 为 这 一 点, 很 多 人 都 认 为 被 const 修 饰 的 值 是 常 量 这 是 不 精 确 的, 精 确 的 说 应 该 是 只 读 的 变 量, 其 值 在 编 译 时 不 能 被 使 用, 因 为 编 译 器 在 编 译 时 不 知 道 其 存 储 的 内 容 或 许 当 初 这 个 关 键 字 应 该 被 替 换 为 readonly 那 么 这 个 关 键 字 有 什 么 用 处 和 意 义 呢? const 推 出 的 初 始 目 的, 正 是 为 了 取 代 预 编 译 指 令, 消 除 它 的 缺 点, 同 时 继 承 它 的 优 点 我 们 看 看 它 与 define 宏 的 区 别 ( 很 多 人 误 以 为 define 是 关 键 字, 在 这 里 我 提 醒 你 再 回 到 本 章 前 面 看 看 32 个 关 键 字 里 是 否 有 define) ,const 修 饰 的 只 读 变 量 定 义 const 只 读 变 量, 具 有 不 可 变 性 例 如 : const int Max=100; int Array[Max]; 这 里 请 在 Visual C++6.0 里 分 别 创 建.c 文 件 和.cpp 文 件 测 试 一 下 你 会 发 现 在.c 文 件 中, 编 译 器 会 提 示 出 错, 而 在.cpp 文 件 中 则 顺 利 运 行 为 什 么 呢? 我 们 知 道 定 义 一 个 数 组 必 须 指 定 其 元 素 的 个 数 这 也 从 侧 面 证 实 在 C 语 言 中,const 修 饰 的 Max 仍 然 是 变 量, 只 不 过 是 只 读 属 性 罢 了 ; 而 在 C++ 里, 扩 展 了 const 的 含 义, 这 里 就 不 讨 论 了 注 意 :const 修 饰 的 只 读 变 量 必 须 在 定 义 的 同 时 初 始 化, 想 想 为 什 么? 留 一 个 问 题 :case 语 句 后 面 是 否 可 以 是 const 修 饰 的 只 读 变 量 呢? 请 动 手 测 试 一 下 , 节 省 空 间, 避 免 不 必 要 的 内 存 分 配, 同 时 提 高 效 率 编 译 器 通 常 不 为 普 通 const 只 读 变 量 分 配 存 储 空 间, 而 是 将 它 们 保 存 在 符 号 表 中, 这 使 得 它 成 为 一 个 编 译 期 间 的 值, 没 有 了 存 储 与 读 内 存 的 操 作, 使 得 它 的 效 率 也 很 高 例 如 : #define M 3 // 宏 常 量 const int N=5; // 此 时 并 未 将 N 放 入 内 存 中... int i=n; // 此 时 为 N 分 配 内 存, 以 后 不 再 分 配! int I=M; // 预 编 译 期 间 进 行 宏 替 换, 分 配 内 存 int j=n; // 没 有 内 存 分 配 int J=M; // 再 进 行 宏 替 换, 又 一 次 分 配 内 存! const 定 义 的 只 读 变 量 从 汇 编 的 角 度 来 看, 只 是 给 出 了 对 应 的 内 存 地 址, 而 不 是 象 #define 一 样 给 出 的 是 立 即 数, 所 以,const 定 义 的 只 读 变 量 在 程 序 运 行 过 程 中 只 有 一 份 拷 贝 ( 因 为 它 是 全 局 的 只 读 变 量, 存 放 在 静 态 区 ), 而 #define 定 义 的 宏 常 量 在 内 存 中 有 若 干 个 拷 贝 #define 宏 是 在 预 编 译 阶 段 进 行 替 换, 而 const 修 饰 的 只 读 变 量 是 在 编 译 的 时 候 确 定 其 值 #define 宏 没 有 类 型, 而 const 修 饰 的 只 读 变 量 具 有 特 定 的 类 型

36 1.11.3, 修 饰 一 般 变 量 一 般 常 量 是 指 简 单 类 型 的 只 读 变 量 这 种 只 读 变 量 在 定 义 时, 修 饰 符 const 可 以 用 在 类 型 说 明 符 前, 也 可 以 用 在 类 型 说 明 符 后 例 如 : int const i=2; 或 const int i=2; , 修 饰 数 组 定 义 或 说 明 一 个 只 读 数 组 可 采 用 如 下 格 式 : int const a[5]=1, 2, 3, 4, 5; 或 const int a[5]=1, 2, 3, 4, 5; , 修 饰 指 针 const int *p; // p 可 变,p 指 向 的 对 象 不 可 变 int const *p; // p 可 变,p 指 向 的 对 象 不 可 变 int*constp; //p 不 可 变,p 指 向 的 对 象 可 变 const int *const p; // 指 针 p 和 p 指 向 的 对 象 都 不 可 变 在 平 时 的 授 课 中 发 现 学 生 很 难 记 住 这 几 种 情 况 这 里 给 出 一 个 记 忆 和 理 解 的 方 法 : 先 忽 略 类 型 名 ( 编 译 器 解 析 的 时 候 也 是 忽 略 类 型 名 ), 我 们 看 const 离 哪 个 近 近 水 楼 台 先 得 月, 离 谁 近 就 修 饰 谁 const int *p; //const 修 饰 *p,p 是 指 针,*p 是 指 针 指 向 的 对 象, 不 可 变 int const *p; //const 修 饰 *p,p 是 指 针,*p 是 指 针 指 向 的 对 象, 不 可 变 int *const p; //const 修 饰 p,p 不 可 变,p 指 向 的 对 象 可 变 const int *const p; // 前 一 个 const 修 饰 *p, 后 一 个 const 修 饰 p, 指 针 p 和 p 指 向 的 对 象 都 不 可 变 , 修 饰 函 数 的 参 数 const 修 饰 符 也 可 以 修 饰 函 数 的 参 数, 当 不 希 望 这 个 参 数 值 被 函 数 体 内 意 外 改 变 时 使 用 例 如 : void Fun(const int i); 告 诉 编 译 器 i 在 函 数 体 中 的 不 能 改 变, 从 而 防 止 了 使 用 者 的 一 些 无 意 的 或 错 误 的 修 改 , 修 饰 函 数 的 返 回 值 const 修 饰 符 也 可 以 修 饰 函 数 的 返 回 值, 返 回 值 不 可 被 改 变 例 如 : const int Fun (void); 在 另 一 连 接 文 件 中 引 用 const 只 读 变 量 : extern const int i; // 正 确 的 声 明 extern const int j=10; // 错 误! 只 读 变 量 的 值 不 能 改 变 注 意 这 里 是 声 明 不 是 定 义, 关 于 声 明 和 定 义 的 区 别, 请 看 本 章 开 始 处 讲 了 这 么 多 讲 完 了 吗? 远 没 有 在 C++ 里, 对 const 做 了 进 一 步 的 扩 展, 还 有 很 多 知 识 未 能

37 讲 完 有 兴 趣 的 话, 不 妨 查 找 相 关 资 料 研 究 研 究 1.12, 最 易 变 的 关 键 字 ----volatile volatile 是 易 变 的 不 稳 定 的 意 思 很 多 人 根 本 就 没 见 过 这 个 关 键 字, 不 知 道 它 的 存 在 也 有 很 多 程 序 员 知 道 它 的 存 在, 但 从 来 没 用 过 它 我 对 它 有 种 杨 家 有 女 初 长 成, 养 在 深 闺 人 未 识 的 感 觉 volatile 关 键 字 和 const 一 样 是 一 种 类 型 修 饰 符, 用 它 修 饰 的 变 量 表 示 可 以 被 某 些 编 译 器 未 知 的 因 素 更 改, 比 如 操 作 系 统 硬 件 或 者 其 它 线 程 等 遇 到 这 个 关 键 字 声 明 的 变 量, 编 译 器 对 访 问 该 变 量 的 代 码 就 不 再 进 行 优 化, 从 而 可 以 提 供 对 特 殊 地 址 的 稳 定 访 问 先 看 看 下 面 的 例 子 : int i=10; int j = i;//(1) 语 句 int k = i;//(2) 语 句 这 时 候 编 译 器 对 代 码 进 行 优 化, 因 为 在 (1) (2) 两 条 语 句 中,i 没 有 被 用 作 左 值 这 时 候 编 译 器 认 为 i 的 值 没 有 发 生 改 变, 所 以 在 (1) 语 句 时 从 内 存 中 取 出 i 的 值 赋 给 j 之 后, 这 个 值 并 没 有 被 丢 掉, 而 是 在 (2) 语 句 时 继 续 用 这 个 值 给 k 赋 值 编 译 器 不 会 生 成 出 汇 编 代 码 重 新 从 内 存 里 取 i 的 值, 这 样 提 高 了 效 率 但 要 注 意 :(1) (2) 语 句 之 间 i 没 有 被 用 作 左 值 才 行 再 看 另 一 个 例 子 : volatile int i=10; int j = i;//(3) 语 句 int k = i;//(4) 语 句 volatile 关 键 字 告 诉 编 译 器 i 是 随 时 可 能 发 生 变 化 的, 每 次 使 用 它 的 时 候 必 须 从 内 存 中 取 出 i 的 值, 因 而 编 译 器 生 成 的 汇 编 代 码 会 重 新 从 i 的 地 址 处 读 取 数 据 放 在 k 中 这 样 看 来, 如 果 i 是 一 个 寄 存 器 变 量 或 者 表 示 一 个 端 口 数 据 或 者 是 多 个 线 程 的 共 享 数 据, 就 容 易 出 错, 所 以 说 volatile 可 以 保 证 对 特 殊 地 址 的 稳 定 访 问 但 是 注 意 : 在 VC++6.0 中, 一 般 Debug 模 式 没 有 进 行 代 码 优 化, 所 以 这 个 关 键 字 的 作 用 有 可 能 看 不 出 来 你 可 以 同 时 生 成 Debug 版 和 Release 版 的 程 序 做 个 测 试 留 一 个 问 题 :const volatile int i=10; 这 行 代 码 有 没 有 问 题? 如 果 没 有, 那 i 到 底 是 什 么 属 性? 1.13, 最 会 带 帽 子 的 关 键 字 ----extern extern, 外 面 的 外 来 的 意 思 那 它 有 什 么 作 用 呢? 举 个 例 子 : 假 设 你 在 大 街 上 看 到

38 一 个 黑 皮 肤 绿 眼 睛 红 头 发 的 美 女 ( 外 星 人?) 或 者 帅 哥 你 的 第 一 反 应 就 是 这 人 不 是 国 产 的 extern 就 相 当 于 他 们 的 这 些 区 别 于 中 国 人 的 特 性 extern 可 以 置 于 变 量 或 者 函 数 前, 以 标 示 变 量 或 者 函 数 的 定 义 在 别 的 文 件 中, 下 面 的 代 码 用 到 的 这 些 变 量 或 函 数 是 外 来 的, 不 是 本 文 件 定 义 的, 提 示 编 译 器 遇 到 此 变 量 和 函 数 时 在 其 他 模 块 中 寻 找 其 定 义 就 好 比 在 本 文 件 中 给 这 些 外 来 的 变 量 或 函 数 带 了 顶 帽 子, 告 诉 本 文 件 中 所 有 代 码, 这 些 家 伙 不 是 土 著 那 你 想 想 extern 修 饰 的 变 量 或 函 数 是 定 义 还 是 声 明? 看 列 子 : A.c 文 件 中 定 义 : B.c 文 件 中 用 extern 修 饰 : int i = 10; extern int i;// 写 成 i=10; 行 吗? void fun(void) extern void fun(void);// 两 个 void 可 否 省 略? //code C.h 文 件 中 定 义 : D.c 文 件 中 用 extern 修 饰 : int j = 1; extern double j;// 这 样 行 吗? 为 什 么? int k = 2; j = 3.0;// 这 样 行 吗? 为 什 么? 至 于 extern C 的 用 法, 一 般 认 为 属 于 C++ 的 范 畴, 这 里 就 先 不 讨 论 当 然 关 于 extern 的 讨 论 还 远 没 有 结 束, 在 指 针 与 数 组 那 一 章, 你 还 会 和 它 亲 密 接 触 的 1.14,struct 关 键 字 struct 是 个 神 奇 的 关 键 字, 它 将 一 些 相 关 联 的 数 据 打 包 成 一 个 整 体, 方 便 使 用 在 网 络 协 议 通 信 控 制 嵌 入 式 系 统 驱 动 开 发 等 地 方, 我 们 经 常 要 传 送 的 不 是 简 单 的 字 节 流 (char 型 数 组 ), 而 是 多 种 数 据 组 合 起 来 的 一 个 整 体, 其 表 现 形 式 是 一 个 结 构 体 经 验 不 足 的 开 发 人 员 往 往 将 所 有 需 要 传 送 的 内 容 依 顺 序 保 存 在 char 型 数 组 中, 通 过 指 针 偏 移 的 方 法 传 送 网 络 报 文 等 信 息 这 样 做 编 程 复 杂, 易 出 错, 而 且 一 旦 控 制 方 式 及 通 信 协 议 有 所 变 化, 程 序 就 要 进 行 非 常 细 致 的 修 改, 非 常 容 易 出 错 这 个 时 候 只 需 要 一 个 结 构 体 就 能 搞 定 平 时 我 们 要 求 函 数 的 参 数 尽 量 不 多 于 4 个, 如 果 函 数 的 参 数 多 于 4 个 使 用 起 来 非 常 容 易 出 错 ( 包 括 每 个 参 数 的 意 义 和 顺 序 都 容 易 弄 错 ), 效 率 也 会 降 低 ( 与 具 体 CPU 有 关,ARM 芯 片 对 于 超 过 4 个 参 数 的 处 理 就 有 讲 究, 具 体 请 参 考 相 关 资 料 ) 这 个 时 候, 可 以 用 结 构 体 压 缩 参 数 个 数 , 空 结 构 体 多 大? 结 构 体 所 占 的 内 存 大 小 是 其 成 员 所 占 内 存 之 和 ( 关 于 结 构 体 的 内 存 对 齐, 请 参 考 预 处 理 那 章 ) 这 点 很 容 易 理 解, 但 是 下 面 的 这 种 情 况 呢?

39 struct student stu; sizeof(stu) 的 值 是 多 少 呢? 在 Visual C 上 测 试 一 下 很 遗 憾, 不 是 0, 而 是 1 为 什 么 呢? 你 想 想, 如 果 我 们 把 struct student 看 成 一 个 模 子 的 话, 你 能 造 出 一 个 没 有 任 何 容 积 的 模 子 吗? 显 然 不 行 编 译 器 也 是 如 此 认 为 编 译 器 认 为 任 何 一 种 数 据 类 型 都 有 其 大 小, 用 它 来 定 义 一 个 变 量 能 够 分 配 确 定 大 小 的 空 间 既 然 如 此, 编 译 器 就 理 所 当 然 的 认 为 任 何 一 个 结 构 体 都 是 有 大 小 的, 哪 怕 这 个 结 构 体 为 空 那 万 一 结 构 体 真 的 为 空, 它 的 大 小 为 什 么 值 比 较 合 适 呢? 假 设 结 构 体 内 只 有 一 个 char 型 的 数 据 成 员, 那 其 大 小 为 1byte( 这 里 先 不 考 虑 内 存 对 齐 的 情 况 ). 也 就 是 说 非 空 结 构 体 类 型 数 据 最 少 需 要 占 一 个 字 节 的 空 间, 而 空 结 构 体 类 型 数 据 总 不 能 比 最 小 的 非 空 结 构 体 类 型 数 据 所 占 的 空 间 大 吧 这 就 麻 烦 了, 空 结 构 体 的 大 小 既 不 能 为 0, 也 不 能 大 于 1, 怎 么 办? 定 义 为 0.5 个 byte? 但 是 内 存 地 址 的 最 小 单 位 是 1 个 byte,0.5 个 byte 怎 么 处 理? 解 决 这 个 问 题 的 最 好 办 法 就 是 折 中, 编 译 器 理 所 当 然 的 认 为 你 构 造 一 个 结 构 体 数 据 类 型 是 用 来 打 包 一 些 数 据 成 员 的, 而 最 小 的 数 据 成 员 需 要 1 个 byte, 编 译 器 为 每 个 结 构 体 类 型 数 据 至 少 预 留 1 个 byte 的 空 间 所 以, 空 结 构 体 的 大 小 就 定 位 1 个 byte , 柔 性 数 组 也 许 你 从 来 没 有 听 说 过 柔 性 数 组 (flexible array) 这 个 概 念, 但 是 它 确 实 是 存 在 的 C99 中, 结 构 中 的 最 后 一 个 元 素 允 许 是 未 知 大 小 的 数 组, 这 就 叫 做 柔 性 数 组 成 员, 但 结 构 中 的 柔 性 数 组 成 员 前 面 必 须 至 少 一 个 其 他 成 员 柔 性 数 组 成 员 允 许 结 构 中 包 含 一 个 大 小 可 变 的 数 组 sizeof 返 回 的 这 种 结 构 大 小 不 包 括 柔 性 数 组 的 内 存 包 含 柔 性 数 组 成 员 的 结 构 用 malloc () 函 数 进 行 内 存 的 动 态 分 配, 并 且 分 配 的 内 存 应 该 大 于 结 构 的 大 小, 以 适 应 柔 性 数 组 的 预 期 大 小 柔 性 数 组 到 底 如 何 使 用 呢? 看 下 面 例 子 : typedef struct st_type int i; int a[0]; type_a; 有 些 编 译 器 会 报 错 无 法 编 译 可 以 改 成 : typedef struct st_type int i; int a[]; type_a; 这 样 我 们 就 可 以 定 义 一 个 可 变 长 的 结 构 体, 用 sizeof(type_a) 得 到 的 只 有 4, 就 是 sizeof(i)=sizeof(int) 那 个 0 个 元 素 的 数 组 没 有 占 用 空 间, 而 后 我 们 可 以 进 行 变 长 操 作 了 通 过 如 下 表 达 式 给 结 构 体 分 配 内 存 : type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));