Untitled

C++ 从 零 开 始 ( 一 ) 何 谓 编 程 引 言 曾 经 有 些 人 问 我 问 题, 问 得 都 是 一 些 很 基 础 的 问 题, 但 这 些 人 却 已 经 能 使 用 VC 编 一 个 对 话 框 界 面 来 进 行 必 要 的 操 作 或 者 是 文 档 / 视 界 面 来 实 时 接 收 端 口 数 据 并 动 态 显 示 曲 线 ( 还 使 用 了 多 线 程 技 术 ), 却 连 那 些 基 础 的 问 题 都 不 清 楚, 并 且 最 严 重 的 后 果 就 是 导 致 编 写 出 拙 劣 的 代 码 ( 虽 然 是 多 线 程, 但 真 不 敢 恭 维 ), 不 清 楚 类 的 含 义, 混 杂 使 用 各 种 可 用 的 技 术 来 达 到 目 的 ( 连 用 异 常 代 替 选 择 语 句 都 弄 出 来 了 ), 代 码 逻 辑 混 乱, 感 觉 就 和 金 山 快 译 的 翻 译 效 果 一 样 我 认 为 任 何 事 情, 基 础 都 是 最 重 要 的, 并 且 在 做 完 我 自 定 的 最 后 一 个 项 目 后 我 就 不 再 做 编 程 的 工 作, 守 着 这 些 经 验 也 没 什 么 意 义, 在 此 就 用 本 系 列 说 说 我 对 编 程 的 理 解, 帮 助 对 电 脑 编 程 感 兴 趣 的 人 快 速 入 门 ( 不 过 也 许 并 不 会 想 象 地 那 么 快 ) 由 于 我 从 没 正 经 看 完 过 一 本 C++ 的 书 ( 都 是 零 碎 偶 尔 翻 翻 的 ), 并 且 本 系 列 并 不 是 教 条 式 地 将 那 些 该 死 的 名 词 及 其 解 释 罗 列 一 遍, 而 是 希 望 读 者 能 够 理 解 编 程, 而 不 是 学 会 一 门 语 言 ( 即 不 止 会 英 翻 汉, 还 会 汉 翻 英 ) 整 个 系 列 全 用 我 自 己 的 理 解 来 写 的, 并 无 参 考 其 他 教 材 ( 在 一 些 基 础 概 念 上 还 是 参 考 了 MSDN), 所 以 本 系 列 中 的 内 容 可 能 有 和 经 典 教 材 不 一 致 的 地 方, 但 它 们 的 本 质 应 该 还 是 一 样 的, 只 是 角 度 不 同 而 已 本 系 列 不 会 仔 细 讲 解 C++ 的 每 个 关 键 字 ( 有 些 并 不 重 要 ), 毕 竟 目 的 不 是 C++ 语 言 参 考, 而 是 编 程 入 门 如 果 本 系 列 文 章 中 有 未 提 及 的 内 容, 还 请 参 考 MSDN 中 的 C++ 语 言 参 考 ( 看 完 本 系 列 文 章 后 应 该 有 能 力 做 这 件 事 了 ), 而 本 系 列 给 出 的 内 容 均 是 以 VC 编 译 器 为 基 础, 基 于 32 位 Windows 操 作 系 统 的 下 面 罗 列 一 下 各 文 章 的 标 题 和 主 要 内 容, 红 色 修 饰 的 文 章 标 题 表 示 我 认 为 的 重 点 C++ 从 零 开 始 ( 一 ) 何 谓 编 程 ( 说 明 编 程 的 真 正 含 义 及 两 个 重 要 却 容 易 被 忽 略 的 基 础 概 念 ) C++ 从 零 开 始 ( 二 ) 何 谓 表 达 式 ( 说 明 各 操 作 符 的 用 处, 但 不 是 全 部, 剩 余 的 会 在 其 它 文 章 提 到 ) C++ 从 零 开 始 ( 三 ) 何 谓 变 量 ( 说 明 电 脑 的 工 作 方 式, 阐 述 内 存 地 址 等 极 其 重 要 的 概 念 ) C++ 从 零 开 始 ( 四 ) 赋 值 操 作 符 ( C++ 从 零 开 始 ( 二 ) 的 延 续, 并 为 指 针 的 解 释 打 一 点 基 础 ) C++ 从 零 开 始 ( 五 ) 何 谓 指 针 ( 阐 述 指 针 数 组 等 重 要 的 概 念 ) C++ 从 零 开 始 ( 六 ) 何 谓 语 句 ( 讲 解 C++ 提 供 的 各 个 语 句, 说 明 各 自 存 在 的 理 由 ) C++ 从 零 开 始 ( 七 ) 何 谓 函 数 ( 说 明 函 数 及 其 存 在 的 理 由 ) C++ 从 零 开 始 ( 八 ) C++ 样 例 一 ( 给 出 一 两 个 简 单 算 法, 一 步 步 说 明 如 何 从 算 法 编 写 出 C++ 代 码 ) C++ 从 零 开 始 ( 九 ) 何 谓 结 构 ( 简 要 说 明 结 构 枚 举 等 及 其 存 在 的 理 由 ) C++ 从 零 开 始 ( 十 ) 何 谓 类 ( 说 明 类 及 其 存 在 的 理 由, 以 及 声 明 定 义 头 文 件 等 概 念 ) C++ 从 零 开 始 ( 十 一 ) 类 的 相 关 知 识 ( 说 明 派 生 继 承 名 字 空 间 操 作 符 重 载 等 ) C++ 从 零 开 始 ( 十 二 ) 何 谓 面 向 对 象 编 程 思 想 ( 阐 述 何 谓 编 程 思 想, 重 点 讲 述 面 向 对 象 编 程 思 想 ) C++ 从 零 开 始 ( 十 三 ) C++ 样 例 二 ( 说 明 如 何 设 计 基 于 面 向 对 象 编 程 思 想 的 C+ + 程 序 ) C++ 从 零 开 始 ( 十 四 ) 何 谓 模 板 ( 说 明 模 板 技 术 及 其 存 在 的 理 由 ) C++ 从 零 开 始 ( 十 五 ) 何 谓 异 常 ( 说 明 异 常 技 术 及 其 存 在 的 理 由 ) C++ 从 零 开 始 ( 十 六 ) 何 谓 预 编 译 指 令 ( 说 明 预 编 译 指 令 的 概 念 及 几 个 常 用 指 令 的 应 用 ) C++ 从 零 开 始 ( 十 七 ) C++ 中 的 一 些 生 僻 关 键 字 (explicit mutable vol

明 ) C++ 从 零 开 始 ( 十 八 ) 何 谓 SDK( 说 明 为 什 么 没 有 放 音 乐 的 指 令 却 依 然 可 以 编 出 放 音 乐 的 程 序 ) C++ 从 零 开 始 ( 十 九 ) 何 谓 C 运 行 时 期 库 ( 说 明 C 运 行 时 期 库 这 一 大 多 数 问 题 的 元 凶 ) C++ 从 零 开 始 ( 二 十 ) 关 于 VC 的 一 点 点 基 础 知 识 ( 说 明 VC 的 几 个 基 本 概 念 和 一 些 常 用 设 置 ) C++ 从 零 开 始 ( 二 十 一 ) C++ 样 例 三 ( 使 用 VC 编 写 一 个 通 过 DLL 实 现 多 态 性 的 简 单 程 序 ) 何 谓 程 序 程 序, 即 过 程 的 顺 序, 准 确 地 说 应 该 是 顺 序 排 列 的 多 个 过 程, 其 是 方 法 的 描 述 比 如 吃 菜, 先 用 筷 子 夹 起 菜, 再 用 筷 子 将 菜 送 入 嘴 中, 最 后 咀 嚼 并 吞 下 其 中 的 夹 送 咀 嚼 和 吞 下 就 被 称 作 命 令, 而 菜 则 是 资 源, 其 状 态 ( 如 形 状 位 置 等 ) 随 着 命 令 的 执 行 而 不 断 发 生 变 化 上 面 就 是 吃 菜 这 个 方 法 的 描 述, 也 就 是 吃 菜 的 程 序 任 何 方 法 都 是 为 了 改 变 某 些 资 源 的 状 态 而 存 在, 因 此 任 何 方 法 的 描 述, 也 就 是 程 序, 也 都 一 定 有 命 令 这 个 东 西 以 及 其 所 作 用 的 资 源 命 令 是 由 程 序 的 执 行 者 来 实 现 的, 比 如 上 面 的 吃 菜, 其 中 的 夹 送 等 都 是 由 吃 菜 的 人 来 实 现 的, 而 资 源 则 一 定 是 执 行 者 可 以 改 变 的 东 西, 而 命 令 只 是 告 诉 执 行 者 如 何 改 变 而 已 电 脑 程 序 和 上 面 一 样, 是 方 法 的 描 述, 而 这 些 方 法 就 是 人 期 望 电 脑 能 做 的 事 ( 注 意 不 是 电 脑 要 做 的 事, 这 经 常 一 直 混 淆 着 许 多 人 ), 当 人 需 要 做 这 些 事 时, 人 再 给 出 某 些 资 源 以 期 电 脑 能 对 其 做 正 确 的 改 变 如 计 算 圆 周 率 的 程 序, 其 只 是 方 法 的 描 述, 本 身 是 不 能 发 生 任 何 效 用 的, 直 到 它 被 执 行, 人 为 给 定 它 一 块 内 存 ( 关 于 内 存, 请 参 考 C++ 从 零 开 始 ( 三 ) ), 告 诉 它 计 算 结 果 的 精 度 及 计 算 结 果 的 存 放 位 置 后, 其 才 改 变 人 为 给 定 的 这 块 内 存 的 状 态 以 表 现 出 计 算 结 果 因 此, 对 于 电 脑 程 序, 命 令 就 是 CPU 的 指 令, 而 执 行 者 也 就 由 于 是 CPU 的 指 令 而 必 须 是 CPU 了, 而 最 后 的 资 源 则 就 是 CPU 可 以 改 变 其 状 态 的 内 存 ( 当 然 不 止, 如 端 口 等, 不 过 一 般 应 用 程 序 都 大 量 使 用 内 存 罢 了 ) 所 以, 电 脑 程 序 就 是 电 脑 如 何 改 变 给 定 资 源 ( 一 般 是 内 存, 也 可 以 是 其 他 硬 件 资 源 ) 的 描 述, 注 意 是 描 述, 本 身 没 有 任 何 意 义, 除 非 被 执 行 何 谓 编 程 编 程 就 是 编 写 程 序, 即 制 订 方 法 为 什 么 要 有 方 法? 方 法 是 为 了 说 明 而 之 所 以 要 有 说 明 就 有 很 多 原 因 了, 但 电 脑 编 程 的 根 本 原 因 是 因 为 语 言 不 同, 且 不 仅 不 同, 连 概 念 都 不 相 通 人 类 的 语 言 五 花 八 门, 但 都 可 以 通 过 翻 译 得 到 正 解, 因 为 人 类 生 存 在 同 一 个 四 维 物 理 空 间 中, 具 有 相 同 或 类 似 的 感 知 而 电 脑 程 序 执 行 时 的 CPU 所 能 感 受 到 的 空 间 和 物 理 空 间 严 重 不 同, 所 以 是 不 可 能 将 电 脑 程 序 翻 译 成 人 类 语 言 的 描 述 的 这 很 重 要, 其 导 致 了 大 部 分 程 序 员 编 写 出 的 拙 劣 代 码, 因 为 人 想 的 和 电 脑 想 的 没 有 共 性, 所 以 他 们 在 编 写 程 序 时 就 随 机 地 无 目 的 地 编 写, 进 而 导 致 了 拙 劣 却 可 以 执 行 的 代 码 电 脑 的 语 言 就 是 CPU 的 指 令, 因 为 CPU 就 这 一 个 感 知 途 径 ( 准 确 地 说 还 有 内 存 定 位 中 断 响 应 等 感 知 途 径 ), 不 像 人 类 还 能 有 肢 体 语 言, 所 以 电 脑 编 程 就 是 将 人 类 语 言 书 写 的 方 法 翻 译 成 相 应 的 电 脑 语 言, 是 一 个 翻 译 过 程 这 完 全 不 同 于 一 般 的 翻 译, 由 于 前 面 的 红 字, 所 以 是 不 可 能 翻 译 的 既 然 不 可 能 翻 译, 那 电 脑 编 程 到 底 是 干 甚? 考 虑 一 个 木 匠, 我 是 客 人 我 对 木 匠 说 我 要 一 把 摇 椅, 躺 着 很 舒 服 的 那 种 然 后 木 匠 开 始 刨 木 头, 按 照 一 个 特 殊 的 曲 线 制 作 摇 椅 下 面 的 曲 木 以 保 证 我 摇 的 时 候 重 心 始 终 不 变 以 感 觉 很 舒 服 这 里 我 编 了 个 简 单 的 程 序, 只 有 一 条 指 令 做 一 把 摇 着 很 舒 服 的 摇 椅 而 木 匠 则 将 我 的 程 序 翻 译 成 了 刨 木 头 设 计 特 定 的 曲 木 等 一 系 列 我 看 不 懂 的 程 序 之 所 以 会 这 样, 在 这 里 就 是 因 为 我 生 活 的 空 间 和 木 工 ( 是 木 工 工 艺, 不 是 木 匠 ) 没 有 共 性 这 里 木 匠 就 相 当 于 电 脑 程 序 员 兼 CPU( 因 为 最 后 由

木 匠 来 制 作 摇 椅 ), 而 木 匠 的 手 艺 就 是 CPU 的 指 令 定 义, 而 木 匠 就 将 我 的 程 序 翻 译 成 了 木 工 的 一 些 规 程, 由 木 匠 通 过 其 手 艺 来 实 现 这 些 规 程, 也 就 是 执 行 程 序 上 面 由 于 我 生 活 的 空 间 和 木 工 ( 指 木 工 工 艺, 不 是 工 人 ) 没 有 共 性, 所 以 是 不 可 能 翻 译 的, 但 上 面 翻 译 成 功 了, 实 际 是 没 有 翻 译 的 在 木 工 眼 中, 那 个 摇 椅 只 是 一 些 直 木 和 曲 木 的 拼 接 而 已, 因 为 木 工 空 间 中 根 本 没 有 摇 椅 的 概 念, 只 是 我 要 把 那 堆 木 头 当 作 摇 椅, 进 而 使 用 如 果 我 把 那 堆 木 头 当 作 凶 器, 则 它 就 是 凶 器, 不 是 什 么 摇 椅 了 废 话 加 荒 谬 加 放 屁!, 也 许 你 会 这 么 大 叫, 但 电 脑 编 程 就 是 这 么 一 回 事 CPU 只 能 感 知 指 令 和 改 变 内 存 的 状 态 ( 不 考 虑 其 他 的 硬 件 资 源 及 响 应 ), 如 果 我 们 编 写 了 一 个 计 算 圆 周 率 的 程 序, 给 出 了 一 块 内 存, 并 执 行, 完 成 后 就 看 见 电 脑 的 屏 幕 显 示 正 确 的 结 果 但 一 定 注 意, 这 里 电 脑 实 际 只 是 将 一 些 内 存 的 数 值 复 制 加 减 乘 除 而 已, 电 脑 并 不 知 道 那 是 圆 周 率, 而 如 果 执 行 程 序 的 人 不 把 它 说 成 是 圆 周 率 那 么 那 个 结 果 也 就 不 是 圆 周 率 了, 可 能 是 一 个 随 机 数 或 其 他 什 么 的, 只 是 运 气 极 好 地 和 圆 周 率 惊 人 地 相 似 上 面 的 东 西 我 将 其 称 为 语 义, 即 语 言 的 意 义, 其 不 仅 仅 可 应 用 在 电 脑 编 程 方 面, 实 际 上 许 多 技 术, 如 机 械 电 子 数 学 等 都 有 自 己 的 语 言, 而 那 些 设 计 师 则 负 责 将 客 户 的 简 单 程 序 翻 译 成 相 应 语 言 描 述 的 程 序 作 为 一 个 程 序 员 是 极 其 有 必 要 了 解 到 语 义 的 重 要 性 的 ( 我 在 我 的 另 一 篇 文 章 语 义 的 需 要 中 对 代 码 级 的 语 义 做 过 较 详 细 的 阐 述, 有 兴 趣 可 以 参 考 之 ), 在 后 续 的 文 章 中 我 还 将 提 到 语 义 以 及 其 对 编 程 的 影 响, 如 果 你 还 没 有 理 解 编 程 是 什 么 意 思, 随 着 后 续 文 章 的 阅 读 应 该 能 够 越 来 越 明 了 电 脑 编 程 的 基 础 知 识 编 译 器 和 连 接 器 我 从 没 见 过 ( 不 过 应 该 有 ) 任 何 一 本 C++ 教 材 有 讲 过 何 谓 编 译 器 (Compiler) 及 连 接 器 (Linker)( 倒 是 在 很 老 的 C 教 材 中 见 过 ), 现 在 都 通 过 一 个 类 似 VC 这 样 的 编 程 环 境 隐 藏 了 大 量 东 西, 将 这 些 封 装 起 来 在 此, 对 它 们 的 理 解 是 非 常 重 要 的, 本 系 列 后 面 将 大 量 运 用 到 这 两 个 词 汇, 其 决 定 了 能 否 理 解 如 声 明 定 义 外 部 变 量 头 文 件 等 非 常 重 要 的 关 键 前 面 已 经 说 明 了 电 脑 编 程 就 是 一 个 翻 译 过 程, 要 把 用 户 的 程 序 翻 译 成 CPU 指 令, 其 实 也 就 是 机 器 代 码 所 谓 的 机 器 代 码 就 是 用 CPU 指 令 书 写 的 程 序, 被 称 作 低 级 语 言 而 程 序 员 的 工 作 就 是 编 写 出 机 器 代 码 由 于 机 器 代 码 完 全 是 一 些 数 字 组 成 (CPU 感 知 的 一 切 都 是 数 字, 即 使 是 指 令, 也 只 是 1 代 表 加 法 2 代 表 减 法 这 一 类 的 数 字 和 工 作 的 映 射 ), 人 要 记 住 1 是 代 表 加 法 2 是 代 表 减 法 将 比 较 困 难, 并 且 还 要 记 住 第 3 块 内 存 中 放 的 是 圆 周 率, 而 第 4 块 内 存 中 放 的 是 有 效 位 数 所 以 发 明 了 汇 编 语 言, 用 一 些 符 号 表 示 加 法 而 不 再 用 1 了, 如 用 ADD 表 示 加 法 等 由 于 使 用 了 汇 编 语 言, 人 更 容 易 记 住 了, 但 是 电 脑 无 法 理 解 ( 其 只 知 道 1 是 加 法, 不 知 道 ADD 是 加 法, 因 为 电 脑 只 能 看 见 数 字 ), 所 以 必 须 有 个 东 西 将 汇 编 代 码 翻 译 成 机 器 代 码, 也 就 是 所 谓 的 编 译 器 即 编 译 器 是 将 一 种 语 言 翻 译 成 另 一 种 语 言 的 程 序 即 使 使 用 了 汇 编 语 言, 但 由 于 其 几 乎 只 是 将 CPU 指 令 中 的 数 字 映 射 成 符 号 以 帮 助 记 忆 而 已, 还 是 使 用 的 电 脑 的 思 考 方 式 进 行 思 考 的, 不 够 接 近 人 类 的 思 考 习 惯, 故 而 出 现 了 纷 繁 复 杂 的 各 种 电 脑 编 程 语 言, 如 :PASCAL BASIC C 等, 其 被 称 作 高 级 语 言, 因 为 比 较 接 近 人 的 思 考 模 式 ( 尤 其 C++ 的 类 的 概 念 的 推 出 ), 而 汇 编 语 言 则 被 称 作 低 级 语 言 (C 曾 被 称 作 高 级 的 低 级 语 言 ), 因 为 它 们 不 是 很 符 合 人 类 的 思 考 模 式, 人 类 书 写 起 来 比 较 困 难 由 于 CPU 同 样 不 认 识 这 些 PASCAL BASIC 等 语 言 定 义 的 符 号, 所 以 也 同 样 必 须 有 一 个 编 译 器 把 这 些 语 言 编 写 的 代 码 转 成 机 器 代 码 对 于 这 里 将 要 讲 到 的 C++ 语 言, 则 是 C++ 语 言 编 译 器 ( 以 后 的 编 译 器 均 指 C++ 语 言 编 译 器 ) 因 此, 这 里 所 谓 的 编 译 器 就 是 将 我 们 书 写 的 C++ 源 代 码 转 换 成 机 器 代 码 由 于 编 译 器 执 行 一 个 转 换 过 程, 所 以 其 可 以 对 我 们 编 写 的 代 码 进 行 一 些 优 化, 也 就 是 说 其 相 当 于 是 一 个 CPU 指 令 程 序 员, 将 我 们 提 供 的 程 序 翻 译 成 机 器 代 码, 不 过 它 的 工 作 要 简 单 一 些 了, 因 为 从 人 类 的 思 考 方 式 转 成 电 脑 的 思 考 方 式 这 一 过 程 已 经 由 程 序 员 完 成 了, 而 编 译 器 只 是 进 行 翻 译 罢 了 ( 最 多 进 行 一 些 优 化 ) 还 有 一 种 编 译 器 被 称 作 翻 译 器 (Translator), 其 和 编 译 器 的 区 别 就 是 其 是 动 态 的 而 编 译 器 是 静 态 的 如 前 面 的 BASIC 的 编 译 器 在 早 期 版 本 就 被 称 为 翻 译 器, 因 为 其 是 在 运 行 时 期 即 时 进 行 翻 译 工 作 的, 而 不 像 编 译 器 一 次 性 将 所 有 代 码 翻 成 机 器 代 码 对 于 这 里 的 动 态 静 态 和 运 行 时 期 等 名 词, 不 用 刻 意 去 理 解 它, 随 着 后 续 文 章 的 阅 读 就 会 了

解 了 编 译 器 把 编 译 后 ( 即 翻 译 好 的 ) 的 代 码 以 一 定 格 式 ( 对 于 VC, 就 是 COFF 通 用 对 象 文 件 格 式, 扩 展 名 为.obj) 存 放 在 文 件 中, 然 后 再 由 连 接 器 将 编 译 好 的 机 器 代 码 按 一 定 格 式 ( 在 Windows 操 作 系 统 下 就 是 Portable Executable File Format P 中, 以 便 以 后 操 作 系 统 执 行 程 序 时 能 按 照 那 个 格 式 找 到 应 该 执 行 的 第 一 条 指 令 或 其 他 东 西, 如 资 源 等 至 于 为 什 么 中 间 还 要 加 一 个 连 接 器 以 及 其 它 细 节, 在 后 续 文 章 中 将 会 进 一 步 说 明 也 许 你 还 不 能 了 解 到 上 面 两 个 概 念 的 重 要 性, 但 在 后 续 的 文 章 中, 你 将 会 发 现 它 们 是 如 此 的 重 要 以 至 于 完 全 有 必 要 在 这 唠 叨 一 番

C++ 从 零 开 始 ( 二 ) 何 谓 表 达 式 本 篇 是 此 系 列 的 开 头, 在 学 英 语 时, 第 一 时 间 学 的 是 字 母, 其 是 英 语 的 基 础 同 样, 在 C++ 中, 所 有 的 代 码 都 是 通 过 标 识 符 (Identifier) 表 达 式 (Expression) 和 语 句 (Statement) 及 一 些 必 要 的 符 号 ( 如 大 括 号 等 ) 组 成, 在 此 先 说 明 何 谓 标 识 符 标 识 符 标 识 符 是 一 个 字 母 序 列, 由 大 小 写 英 文 字 母 下 划 线 及 数 字 组 成, 用 于 标 识 标 识 就 是 标 出 并 识 别, 也 就 是 名 字 其 可 以 作 为 后 面 将 提 到 的 变 量 或 者 函 数 或 者 类 等 的 名 字, 也 就 是 说 用 来 标 识 某 个 特 定 的 变 量 或 者 函 数 或 者 类 等 C++ 中 的 元 素 比 如 :abc 就 是 一 个 合 法 的 标 识 符, 即 abc 可 以 作 为 变 量 函 数 等 元 素 的 名 字, 但 并 不 代 表 abc 就 是 某 个 变 量 或 函 数 的 名 字, 而 所 谓 的 合 法 就 是 任 何 一 个 标 识 符 都 必 须 不 能 以 数 字 开 头, 只 能 包 括 大 小 写 英 文 字 母 下 划 线 及 数 字, 不 能 有 其 它 符 号, 如,!^ 等, 并 且 不 能 与 C++ 关 键 字 相 同 也 就 是 我 们 在 给 一 个 变 量 或 函 数 起 名 字 的 时 候, 必 须 将 起 的 名 字 看 作 是 一 个 标 识 符, 并 进 而 必 须 满 足 上 面 提 出 的 要 求 如 12ab_C 就 不 是 一 个 合 法 的 标 识 符, 因 此 我 们 不 能 给 某 个 变 量 或 函 数 起 12ab_C 这 样 的 名 字 ;ab_12c 就 是 合 法 的 标 识 符, 因 此 可 以 被 用 作 变 量 或 函 数 的 名 字 前 面 提 到 关 键 字, 在 后 续 的 语 句 及 一 些 声 明 修 饰 符 的 介 绍 中 将 发 现,C++ 提 供 了 一 些 特 殊 的 标 识 符 作 为 语 句 的 名 字, 用 以 标 识 某 一 特 定 语 句, 如 if while 等 ; 或 者 提 供 一 些 修 饰 符 用 以 修 饰 变 量 函 数 等 元 素 以 实 现 语 义 或 给 编 译 器 及 连 接 器 提 供 一 些 特 定 信 息 以 进 行 优 化 查 错 等 操 作, 如 extern static 等 因 此 在 命 名 变 量 或 函 数 或 其 他 元 素 时, 不 能 使 用 if extern 等 这 种 C++ 关 键 字 作 为 名 字, 否 则 将 导 致 编 译 器 无 法 确 认 是 一 个 变 量 ( 或 函 数 或 其 它 C++ 元 素 ) 还 是 一 条 语 句, 进 而 无 法 编 译 如 果 要 让 某 个 标 识 符 是 特 定 变 量 或 函 数 或 类 的 名 字, 就 需 要 使 用 声 明, 在 后 续 的 文 章 中 再 具 体 说 明 数 字 C++ 作 为 电 脑 编 程 语 言, 电 脑 是 处 理 数 字 的, 因 此 C++ 中 的 基 础 东 西 就 是 数 字 C+ + 中 提 供 两 种 数 字 : 整 型 数 和 浮 点 数, 也 就 是 整 数 和 小 数 但 由 于 电 脑 实 际 并 不 是 想 象 中 的 数 字 化 的 ( 详 情 参 见 C++ 从 零 开 始 ( 三 ) 中 的 类 型 一 节 ), 所 以 整 型 数 又 分 成 了 有 符 号 和 无 符 号 整 型 数, 而 浮 点 数 则 由 精 度 的 区 别 而 分 成 单 精 度 和 双 精 度 浮 点 数, 同 样 的 整 型 数 也 根 据 长 度 分 成 长 整 型 和 短 整 型 要 在 C++ 代 码 中 表 示 一 个 数 字, 直 接 书 写 数 字 即 可, 如 :123 34.23-34.34 等 由 于 电 脑 并 非 以 数 字 为 基 础 而 导 致 了 前 面 数 字 的 分 类, 为 了 在 代 码 中 表 现 出 来,C++ 提 供 了 一 系 列 的 后 缀 进 行 表 示, 如 下 : u 或 U 表 示 数 字 是 无 符 号 整 型 数, 如 :123u, 但 并 不 说 明 是 长 整 型 还 是 短 整 型 l 或 L 表 示 数 字 是 长 整 型 数, 如 :123l; 而 123ul 就 是 无 符 号 长 整 型 数 ; 而 34.4l 就 是 长 双 精 度 浮 点 数, 等 效 于 双 精 度 浮 点 数 i64 或 I64 表 示 数 字 是 长 长 整 型 数, 其 是 为 64 位 操 作 系 统 定 义 的, 长 度 比 长 整 型 数 长 如 :43i64 f 或 F 表 示 数 字 是 单 精 度 浮 点 数, 如 :12.3f e 或 E 表 示 数 字 的 次 幂, 如 :34.4e-2 就 是 0.344;0.2544e3f 表 示 一 个 单 精 度 浮 点 数 254.4 当 什 么 后 缀 都 没 写 时, 则 根 据 有 无 小 数 点 及 位 数 来 决 定 其 具 体 类 型, 如 :123 表 示 的 是 有 符 号 整 型 数, 而 12341434 则 是 有 符 号 长 整 型 数 ; 而 34.43 表 示 双 精 度 浮 点 数 为 什 么 要 搞 这 么 多 事 出 来, 还 分 什 么 有 符 号 无 符 号 之 类 的? 这 全 是 因 为 电 脑 并 非 基 于 数 字 的, 而 是 基 于 状 态 的, 详 情 在 下 篇 中 将 详 细 说 明

作 为 科 学 计 算, 可 能 经 常 会 碰 到 使 用 非 十 进 制 数 字, 如 16 进 制 8 进 制 等,C++ 也 为 此 提 供 了 一 些 前 缀 以 进 行 支 持 在 数 字 前 面 加 上 0x 或 0X 表 示 这 个 数 字 是 16 进 制 表 示 的, 如 :0xF3Fa 0x11cF 而 在 前 加 一 个 0 则 表 示 这 个 数 字 是 用 8 进 制 表 示 的, 如 :0347, 变 为 十 进 制 数 就 为 231 但 16 进 制 和 8 进 制 都 不 能 用 于 表 示 浮 点 数, 只 能 表 示 整 型 数, 即 0x34.343 是 错 误 的 字 符 串 C++ 除 了 提 供 数 字 这 种 最 基 础 的 表 示 方 式 外, 还 提 供 了 字 符 及 字 符 串 这 完 全 只 是 出 于 方 便 编 写 程 序 而 提 供 的,C++ 作 为 电 脑 语 言, 根 本 没 有 提 供 字 符 串 的 必 要 性 不 过 由 于 人 对 电 脑 的 基 本 要 求 就 是 显 示 结 果, 而 字 符 和 字 符 串 都 由 于 是 人 易 读 的 符 号 而 被 用 于 显 示 结 果, 所 以 C++ 专 门 提 供 了 对 字 符 串 的 支 持 前 面 说 过, 电 脑 只 认 识 数 字, 而 字 符 就 是 文 字 符 号, 是 一 种 图 形 符 号 为 了 使 电 脑 能 够 处 理 符 号, 必 须 通 过 某 种 方 式 将 符 号 变 成 数 字, 在 电 脑 中 这 通 过 在 符 号 和 数 字 之 间 建 立 一 个 映 射 来 实 现, 也 就 是 一 个 表 格 表 格 有 两 列, 一 列 就 是 我 们 欲 显 示 的 图 形 符 号, 而 另 一 列 就 是 一 个 数 字, 通 过 这 么 一 张 表 就 可 以 在 图 形 符 号 和 数 字 之 间 建 立 映 射 现 在 已 经 定 义 出 一 标 准 表, 称 为 ASCII 码 表, 几 乎 所 有 的 电 脑 硬 件 都 支 持 这 个 转 换 表 以 将 数 字 变 成 符 号 进 而 显 示 计 算 结 果 有 了 上 面 的 表, 当 想 说 明 结 果 为 A 时, 就 查 ASCII 码 表, 得 到 A 这 个 图 形 符 号 对 应 的 数 字 是 65, 然 后 就 告 诉 电 脑 输 出 序 号 为 65 的 字 符, 最 后 屏 幕 上 显 示 A 这 明 显 地 繁 杂 得 异 常, 为 此 C++ 就 提 供 了 字 符 和 字 符 串 当 我 们 想 得 到 某 一 个 图 形 符 号 的 ASCII 码 表 的 序 号 时, 只 需 通 过 单 引 号 将 那 个 字 符 括 起 来 即 可, 如 :'A', 其 效 果 和 65 是 一 样 的 当 要 使 用 不 止 一 个 字 符 时, 则 用 双 引 号 将 多 个 字 符 括 起 来, 也 就 是 所 谓 的 字 符 串 了, 如 :"ABC" 因 此 字 符 串 就 是 多 个 字 符 连 起 来 而 已 但 根 据 前 面 的 说 明 易 发 现, 字 符 串 也 需 要 映 射 成 数 字, 但 它 的 映 射 就 不 像 字 符 那 么 简 单 可 以 通 过 查 表 就 搞 定 的, 对 于 此, 将 在 后 续 文 章 中 对 数 组 作 过 介 绍 后 再 说 明 操 作 符 电 脑 的 基 本 是 数 字, 那 么 电 脑 的 所 有 操 作 都 是 改 变 数 字, 因 此 很 正 常 地 C++ 提 供 了 操 作 数 字 的 一 些 基 本 操 作, 称 作 操 作 符 (Operator), 如 :+ - * / 等 任 何 操 作 符 都 要 返 回 一 个 数 字, 称 为 操 作 符 的 返 回 值, 因 此 操 作 符 就 是 操 作 数 字 并 返 回 数 字 的 符 号 作 为 一 般 性 地 分 类, 按 操 作 符 同 时 作 用 的 数 字 个 数 分 为 一 元 二 元 和 三 元 操 作 符 一 元 操 作 符 有 : 关 于 其 他 的 一 元 操 作 符 将 在 后 续 文 章 中 陆 续 提 到 ( 但 不 一 定 全 部 提 到 ) 二 元 操 作 符 有 :

关 于 其 他 的 二 元 操 作 符 将 在 后 续 文 章 中 陆 续 提 到 ( 但 不 一 定 全 部 提 到 ) 三 元 操 作 符 只 有 一 个, 为?:, 其 格 式 为 :< 数 字 1>?< 数 字 2>:< 数 字 3> 它 的 返 回 值 为 : 如 果 < 数 字 1> 是 逻 辑 真, 返 回 < 数 字 2>, 否 则 返 回 < 数 字 3> 如 : 34?4:2 的 返 回 值 就 是 4, 因 为 34 非 零, 为 逻 辑 真, 返 回 4 而 0?4:2 的 返 回 值 就 是 2, 因 为 为 逻 辑 假, 返 回 2 表 达 式 你 应 该 发 现 前 面 的 荒 谬 之 处 了 12>435 返 回 值 为 0, 那 为 什 么 不 直 接 写 0 还 吃 饱 了 撑 了 写 个 12>435 在 那? 这 就 是 表 达 式 的 意 义 了 前 面 说 > 的 前 后 各 接 一 数 字, 但 是 操 作 符 是 操 作 数 字 并 返 回 数 字 的 符 号, 因 为 它 返 回 数 字, 因 此 可 以 放 在 上 面 说 的 任 何 一 个 要 求 接 数 字 的 地 方, 也 就 形 成 了 所 谓 的 表 达 式 如 :23*54/45>34 的 返 回 值 就 是 0, 因 为 23*54 的 返 回 值 为 1242; 然 后 又 将 1242 作 为 / 的 左 接 数 字, 得 到 新 的 返 回 值 27.6; 最 后 将 27.6 作 为 > 的 左 接 数 字 进 而 得 到 返 回 值 0, 为 逻 辑 假 因 此 表 达 式 就 是 由 一 系 列 返 回 数 字 的 东 西 和 操 作 符 组 合 而 成 的 一 段 代 码, 其 由 于 是 由 操 作 符 组 成 的, 故 一 定 返 回 值 而 前 面 说 的 返 回 数 字 的 东 西 则 可 以 是 另 一 个 表 达 式, 或 者 一 个 变 量, 或 者 一 个 具 有 返 回 值 的 函 数, 或 者 具 有 数 字 类 型 操 作 符 重 载 的 类 的 对 象 等, 反 正 只 要 是 能 返 回 一 个 数 字 的 东 西 如 果 对 于 何 谓 变 量 函 数 类 等 这 些 名 词 感 到 陌 生, 不 需 要 去 管 它 们, 在 后 继 的 文 章 中 将 会 一 一 说 明 因 此 34 也 是 一 个 表 达 式, 其 返 回 值 为 34, 只 不 过 是 没 有 操 作 符 的 表 达 式 罢 了 ( 在 后 面 将 会 了 解 到 34 其 实 是 一 种 操 作 符 ) 故 表 达 式 的 概 念 其 实 是 很 广 的, 只 要 有 返 回 值 的 东 西 就 可 以 称 为 表 达 式

由 于 表 达 式 里 有 很 多 操 作 符, 执 行 操 作 符 的 顺 序 依 赖 于 操 作 符 的 优 先 级, 就 和 数 学 中 的 一 样,* / 的 优 先 级 大 于 + -, 而 + - 又 大 于 > < 等 逻 辑 操 作 符 不 用 去 刻 意 记 住 操 作 符 的 优 先 级, 当 不 能 确 定 操 作 符 的 执 行 顺 序 时, 可 以 使 用 小 括 号 来 进 行 指 定 如 : ((1+2)*3)+3)/4 的 返 回 值 为 3, 而 1+2*3+3/4 的 返 回 值 为 7 注 意 3/4 为 0, 0 当 希 望 进 行 浮 点 数 除 法 或 乘 法 时, 只 需 让 操 作 数 中 的 某 一 个 为 浮 点 数 即 可, 如 :3/4.0 的 返 回 值 为 0.75 & ^ ~ 等 的 应 用 前 面 提 过 逻 辑 操 作 符 &&! 等, 作 为 表 示 逻 辑, 其 被 C++ 提 供 一 点 都 不 值 得 惊 奇 但 是 为 什 么 要 有 一 个 将 数 字 转 成 二 进 制 数, 然 后 对 二 进 制 数 的 各 位 进 行 逻 辑 操 作 的 这 么 一 类 操 作 符 呢? 首 先 是 CPU 提 供 了 相 应 的 指 令, 并 且 其 还 有 着 下 面 这 个 非 常 有 意 义 的 应 用 考 虑 一 十 字 路 口, 每 个 路 口 有 三 盏 红 绿 灯, 分 别 指 明 能 否 左 转 右 转 及 直 行 共 有 12 盏, 现 在 要 为 它 编 写 一 个 控 制 程 序, 不 管 这 程 序 的 功 能 怎 样, 首 先 需 要 将 红 绿 灯 的 状 态 转 化 为 数 字, 因 为 电 脑 只 知 道 数 字 所 以 用 3 个 数 字 分 别 表 示 某 路 口 的 三 盏 红 绿 灯, 因 此 每 个 红 绿 灯 的 状 态 由 一 个 数 字 来 表 示, 假 设 红 灯 为 0, 绿 灯 为 1( 不 考 虑 黄 灯 或 其 他 情 况 ) 后 来 忽 然 发 现, 其 实 也 可 以 用 一 个 数 字 表 示 一 个 路 口 的 三 盏 红 绿 灯 状 态, 如 用 110 表 示 左 转 绿 灯 直 行 绿 灯 而 右 转 红 灯 上 面 的 110 是 一 个 十 进 制 数 字, 它 的 每 一 位 实 际 都 可 以 为 0~9 十 个 数 字, 但 是 这 里 只 应 用 到 了 两 个 :0 和 1, 感 觉 很 浪 费 故 选 择 二 进 制 数 来 表 示, 还 是 110, 但 是 是 二 进 制 数 了, 转 成 十 进 制 数 为 6, 即 使 当 为 111 时 转 成 十 进 制 数 也 只 是 7, 比 前 面 的 110 这 个 十 进 制 数 小 多 了, 节 约 了?? 什 么?? 我 们 在 纸 上 写 数 字 235425234 一 定 比 写 134 这 个 数 字 要 更 多 地 占 用 纸 张 ( 假 设 字 都 一 样 大 ) 因 此 记 录 一 个 大 的 数 比 记 录 一 个 小 的 数 要 花 费 更 多 的 资 源 简 直 荒 谬! 不 管 是 100 还 是 1000, 都 只 是 一 个 数 字, 为 什 么 记 录 大 的 数 字 就 更 费 资 源? 因 为 电 脑 并 不 是 数 字 计 算 机, 而 是 电 子 计 算 机, 它 是 基 于 状 态 而 不 是 基 于 数 字 的, 这 在 下 篇 会 详 细 说 明 电 脑 必 须 使 用 某 种 表 示 方 式 来 代 表 一 个 数 字, 而 那 个 表 示 方 式 和 二 进 制 很 像, 但 并 不 是 二 进 制 数, 故 出 现 记 录 大 的 数 较 小 的 数 更 耗 资 源, 这 也 就 是 为 什 么 上 面 整 型 数 要 分 什 么 长 整 型 短 整 型 的 原 因 了 下 面 继 续 上 面 的 思 考 使 用 了 110 这 个 二 进 制 数 来 表 示 三 盏 红 绿 灯 的 状 态, 那 么 现 在 要 知 道 110 这 个 数 字 代 表 左 转 红 绿 灯 的 什 么 状 态 以 数 字 的 第 三 位 表 示 左 转, 不 过 电 脑 并 不 知 道 这 个, 因 此 如 下 :110&100 这 个 表 达 式 的 返 回 值 是 100, 非 零, 逻 辑 真 假 设 某 路 口 的 状 态 为 010, 则 同 样 的 010&100, 返 回 值 为 0, 逻 辑 假 因 此 使 用 & 操 作 符 可 以 将 二 进 制 数 中 的 某 一 位 或 几 位 的 状 态 提 取 出 来 所 以 我 们 要 了 解 一 个 数 字 代 表 的 红 绿 灯 状 态 中 的 左 转 红 绿 灯 是 否 绿 灯 时, 只 需 让 它 和 100 相 与 即 可 现 在 要 保 持 其 他 红 绿 灯 的 状 态 不 变, 仅 仅 使 左 转 红 绿 灯 为 绿 灯, 如 当 前 状 态 为 010, 为 了 使 左 转 红 绿 灯 为 绿 灯, 值 应 该 为 110, 这 可 以 通 过 010 100 做 到 如 果 当 前 状 态 是 001, 则 001 100 为 101, 正 确 直 行 和 右 转 的 红 绿 灯 状 态 均 没 有 发 生 变 化 因 此 使 用 操 作 符 可 以 给 一 个 二 进 制 数 中 的 某 一 位 或 几 位 设 置 状 态, 但 只 能 设 置 为 1, 如 果 想 设 置 为 0, 如 101, 要 关 掉 左 转 的 绿 灯, 则 101&~100, 返 回 值 为 001 上 面 一 直 提 到 的 路 口 红 绿 灯 的 状 态 实 际 编 写 时 可 以 使 用 一 个 变 量 来 表 示, 而 上 面 的 100 也 可 以 用 一 个 标 识 符 来 表 示, 如 state&ts_left, 就 可 以 表 示 检 查 变 量 state 所 表 示 的 状 态 中 的 左 转 红 绿 灯 的 状 态 上 面 的 这 种 方 法 被 大 量 地 运 用, 如 创 建 一 个 窗 口, 一 个 窗 口 可 能 有 二 三 十 个 风 格, 则 通 过 上 面 的 方 法, 就 可 以 只 用 一 个 32 位 长 的 二 进 制 数 字 就 表 示 了 窗 口 的 风 格, 而 不 用 去 弄 二 三 十 个 数 字 来 分 别 代 表 每 种 风 格 是 否 具 有

C++ 从 零 开 始 ( 三 ) 何 谓 变 量 本 篇 说 明 内 容 是 C++ 中 的 关 键, 基 本 大 部 分 人 对 于 这 些 内 容 都 是 昏 的, 但 这 些 内 容 又 是 编 程 的 基 础 中 的 基 础, 必 须 详 细 说 明 数 字 表 示 数 学 中, 数 只 有 数 值 大 小 的 不 同, 绝 不 会 有 数 值 占 用 空 间 的 区 别, 即 数 学 中 的 数 是 逻 辑 上 的 一 个 概 念, 但 电 脑 不 是 考 虑 算 盘, 每 个 算 盘 上 有 很 多 列 算 子, 每 列 都 分 成 上 下 两 排 算 子 上 排 算 子 有 2 个, 每 个 代 表 5, 下 排 算 子 有 4 个, 每 个 代 表 1( 这 并 不 重 要 ) 因 此 算 盘 上 的 每 列 共 有 6 个 算 子, 每 列 共 可 以 表 示 0 到 14 这 15 个 数 字 ( 因 为 上 排 算 子 的 可 能 状 态 有 0 到 2 个 算 子 有 效, 而 下 排 算 子 则 可 能 有 0 到 4 个 算 子 有 效, 故 为 3 5=15 种 组 合 方 式 ) 上 面 的 重 点 就 是 算 盘 的 每 列 并 没 有 表 示 0 到 14 这 15 个 数 字, 而 是 每 列 有 15 种 状 态, 因 此 被 人 利 用 来 表 示 数 字 而 已 ( 这 很 重 要 ) 由 于 算 盘 的 每 列 有 15 个 状 态, 因 此 用 两 列 算 子 就 可 以 有 15 15=225 个 状 态, 因 此 可 以 表 示 0 到 224 阿 拉 伯 数 字 的 每 一 位 有 0 到 9 这 10 个 图 形 符 号, 用 两 个 阿 拉 伯 数 字 图 形 符 号 时 就 能 有 10 10=100 个 状 态, 因 此 可 以 表 示 0 到 99 这 100 个 数 这 里 的 算 盘 其 实 就 是 一 个 基 于 15 进 制 的 记 数 器 ( 可 以 通 过 维 持 一 列 算 子 的 状 态 来 记 录 一 位 数 字 ), 它 的 一 列 算 子 就 相 当 于 一 位 阿 拉 伯 数 字, 每 列 有 15 种 状 态, 故 能 表 示 从 0 到 14 这 15 个 数 字, 超 出 14 后 就 必 须 通 过 进 位 来 要 求 另 一 列 算 子 的 加 入 以 表 示 数 字 电 脑 与 此 一 样, 其 并 不 是 数 字 计 算 机, 而 是 电 子 计 算 机, 电 脑 中 通 过 一 根 线 的 电 位 高 低 来 表 示 数 字 一 根 线 中 的 电 位 规 定 只 有 两 种 状 态 高 电 位 和 低 电 位, 因 此 电 脑 的 数 字 表 示 形 式 是 二 进 制 的 和 上 面 的 算 盘 一 样, 一 根 电 线 只 有 两 个 状 态, 当 要 表 示 超 出 1 的 数 字 时, 就 必 须 进 位 来 要 求 另 一 根 线 的 加 入 以 表 示 数 字 所 谓 的 32 位 电 脑 就 是 提 供 了 32 根 线 ( 被 称 作 数 据 总 线 ) 来 表 示 数 据, 因 此 就 有 2 的 32 次 方 那 么 多 种 状 态 而 16 根 线 就 能 表 示 2 的 16 次 方 那 么 多 种 状 态 所 以, 电 脑 并 不 是 基 于 二 进 制 数, 而 是 基 于 状 态 的 变 化, 只 不 过 这 个 状 态 可 以 使 用 二 进 制 数 表 示 出 来 而 已 即 电 脑 并 不 认 识 二 进 制 数, 这 是 下 面 类 型 一 节 的 基 础 内 存 内 存 就 是 电 脑 中 能 记 录 数 字 的 硬 件, 但 其 存 储 速 度 很 快 ( 与 硬 盘 等 低 速 存 储 设 备 比 较 ), 又 不 能 较 长 时 间 保 存 数 据, 所 以 经 常 被 用 做 草 稿 纸, 记 录 一 些 临 时 信 息 前 面 已 经 说 过,32 位 计 算 机 的 数 字 是 通 过 32 根 线 上 的 电 位 状 态 的 组 合 来 表 示 的, 因 此 内 存 能 记 录 数 字, 也 就 是 能 维 持 32 根 线 上 各 自 的 电 位 状 态 ( 就 好 象 算 盘 的 算 子 拨 动 后 就 不 会 改 变 位 置, 除 非 再 次 拨 动 它 ) 不 过 依 旧 考 虑 上 面 的 算 盘, 假 如 一 个 算 盘 上 有 15 列 算 子, 则 一 个 算 盘 能 表 示 15 的 15 次 方 个 状 态, 是 很 大 的 数 字, 但 经 常 实 际 是 不 会 用 到 变 化 那 么 大 的 数 字 的, 因 此 让 一 个 算 盘 只 有 两 列 算 子, 则 只 能 表 示 225 个 状 态, 当 数 字 超 出 时 就 使 用 另 一 个 或 多 个 算 盘 来 一 起 表 示 上 面 不 管 是 2 列 算 子 还 是 15 列 算 子, 都 是 算 盘 的 粒 度, 粒 度 分 得 过 大 造 成 不 必 要 的 浪 费 ( 很 多 列 算 子 都 不 使 用 ), 太 小 又 很 麻 烦 ( 需 要 多 个 算 盘 ) 电 脑 与 此 一 样 2 的 32 次 方 可 表 示 的 数 字 很 大, 一 般 都 不 会 用 到, 如 果 直 接 以 32 位 存 储 在 内 存 中 势 必 造 成 相 当 大 的 资 源 浪 费 于 是 如 上, 规 定 内 存 的 粒 度 为 8 位 二 进 制 数, 称 为 一 个 内 存 单 元, 而 其 大 小 称 为 一 个 字 节 (Byte) 就 是 说, 内 存 存 储 数 字, 至 少 都 会 记 录 8 根 线 上 的 电 位 状 态, 也 就 是 2 的 8 次 方 共 256 种 状 态 所 以 如 果 一 个 32 位 的 二 进 制 数 要 存 储 在 内 存 中, 就 需 要 占 据 4 个 内 存 单 元, 也 就 是 4 个 字 节 的 内 存 空 间 我 们 在 纸 上 写 字, 是 通 过 肉 眼 判 断 出 字 在 纸 上 的 相 对 横 坐 标 和 纵 坐 标 以 查 找 到 要 看 的 字 或 要 写 字 的 位 置 同 样, 由 于 内 存 就 相 当 于 草 稿 纸, 因 此 也 需 要 某 种 定 位 方 式 来 定 位,

在 电 脑 中, 就 是 通 过 一 个 数 字 来 定 位 的 这 就 和 旅 馆 的 房 间 号 一 样, 内 存 单 元 就 相 当 于 房 间 ( 假 定 每 个 房 间 只 能 住 一 个 人 ), 而 前 面 说 的 那 个 数 字 就 相 当 于 房 间 号 为 了 向 某 块 内 存 中 写 入 数 据 ( 就 是 使 用 某 块 内 存 来 记 录 数 据 总 线 上 的 电 位 状 态 ), 就 必 须 知 道 这 块 内 存 对 应 的 数 字, 而 这 个 数 字 就 被 称 为 地 址 而 通 过 给 定 的 地 址 找 到 对 应 的 内 存 单 元 就 称 为 寻 址 因 此 地 址 就 是 一 个 数 字, 用 以 唯 一 标 识 某 一 特 定 内 存 单 元 此 数 字 一 般 是 32 位 长 的 二 进 制 数, 也 就 可 以 表 示 4G 个 状 态, 也 就 是 说 一 般 的 32 位 电 脑 都 具 有 4G 的 内 存 空 间 寻 址 能 力, 即 电 脑 最 多 装 4G 的 内 存, 如 果 电 脑 有 超 过 4G 的 内 存, 此 时 就 需 要 增 加 地 址 的 长 度, 如 用 40 位 长 的 二 进 制 数 来 表 示 类 型 在 本 系 列 最 开 头 时 已 经 说 明 了 何 谓 编 程, 而 刚 才 更 进 一 步 说 明 了 电 脑 其 实 连 数 字 都 不 认 识, 只 是 状 态 的 记 录, 而 所 谓 的 加 法 也 只 是 人 为 设 计 那 个 加 法 器 以 使 得 两 个 状 态 经 过 加 法 器 的 处 理 而 生 成 的 状 态 正 好 和 数 学 上 的 加 法 的 结 果 一 样 而 已 这 一 切 的 一 切 都 只 说 明 一 点 : 电 脑 所 做 的 工 作 是 什 么, 全 视 使 用 的 人 以 为 是 什 么 因 此 为 了 利 用 电 脑 那 很 快 的 计 算 能 力 ( 实 际 是 状 态 的 变 换 能 力 ), 人 为 规 定 了 如 何 解 释 那 些 状 态 为 了 方 便 其 间, 对 于 前 面 提 出 的 电 位 的 状 态, 我 们 使 用 1 位 二 进 制 数 来 表 示, 则 上 面 提 出 的 状 态 就 可 以 使 用 一 个 二 进 制 数 来 表 示, 而 所 谓 的 如 何 解 释 那 些 状 态 就 变 成 了 如 何 解 释 一 个 二 进 制 数 C++ 是 高 级 语 言, 为 了 帮 助 解 释 那 些 二 进 制 数, 提 供 了 类 型 这 个 概 念 类 型 就 是 人 为 制 订 的 如 何 解 释 内 存 中 的 二 进 制 数 的 协 议 C++ 提 供 了 下 面 的 一 些 标 准 类 型 定 义 标 准 类 型 不 止 上 面 的 几 个, 后 面 还 会 陆 续 提 到 上 面 的 长 度 为 2 个 字 节 也 就 是 将 两 个 连 续 的 内 存 单 元 中 的 数 字 取 出 并 合 并 在 一 起 以 表 示 一 个 数 字, 这 和 前 面 说 的 一 个 算 盘 表 示 不 了 的 数 字, 就 进 位 以 加 入 另 一 个 算 盘 帮 助 表 示 是 同 样 的 道 理 上 面 的 signed 关 键 字 是 可 以 去 掉 的, 即 char 等 同 于 signed char, 用 以 简 化 代 码 但 也 仅 限 于 signed, 如 果 是 unsigned char, 则 在 使 用 时 依 旧 必 须 是 unsigned ch 现 在 应 该 已 经 了 解 上 篇 中 为 什 么 数 字 还 要 分 什 么 有 符 号 无 符 号 长 整 型 短 整 型 之 类 的

了, 而 上 面 的 short char 等 也 都 只 是 长 度 不 同, 这 就 由 程 序 员 自 己 根 据 可 能 出 现 的 数 字 变 化 幅 度 来 进 行 选 用 了 类 型 只 是 对 内 存 中 的 数 字 的 解 释, 但 上 面 的 类 型 看 起 来 相 对 简 单 了 点, 且 语 义 并 不 是 很 强, 即 没 有 什 么 特 殊 意 思 为 此,C++ 提 供 了 自 定 义 类 型, 也 就 是 后 继 文 章 中 将 要 说 明 的 结 构 类 等 变 量 在 本 系 列 的 第 一 篇 中 已 经 说 过, 电 脑 编 程 的 绝 大 部 分 工 作 就 是 操 作 内 存, 而 上 面 说 了, 为 了 操 作 内 存, 需 要 使 用 地 址 来 标 识 要 操 作 的 内 存 块 的 首 地 址 ( 上 面 的 long 表 示 连 续 的 4 个 字 节 内 存, 其 第 一 个 内 存 单 元 的 地 址 称 作 这 连 续 4 个 字 节 内 存 块 的 首 地 址 ) 为 此 我 们 在 编 写 程 序 时 必 须 记 下 地 址 做 5+2/3-5*2 的 计 算, 先 计 算 出 2/3 的 值, 写 在 草 稿 纸 上, 接 着 算 出 5*2 的 值, 又 写 在 草 稿 纸 上 为 了 接 下 来 的 加 法 和 减 法 运 算, 必 须 能 够 知 道 草 稿 纸 上 的 两 个 数 字 哪 个 是 2/3 的 值 哪 个 是 5*2 的 值 人 就 是 通 过 记 忆 那 两 个 数 在 纸 上 的 位 置 来 记 忆 的, 而 电 脑 就 是 通 过 地 址 来 标 识 的 但 电 脑 只 会 做 加 减 乘 除, 不 会 去 主 动 记 那 些 2/3 5*2 的 中 间 值 的 位 置, 也 就 是 地 址 因 此 程 序 员 必 须 完 成 这 个 工 作, 将 那 两 个 地 址 记 下 来 问 题 就 是 这 里 只 有 两 个 值, 也 许 好 记 一 些, 但 如 果 多 了, 人 是 很 难 记 住 哪 个 地 址 对 应 哪 个 值 的, 但 人 对 符 号 比 对 数 字 要 敏 感 得 多, 即 人 很 容 易 记 下 一 个 名 字 而 不 是 一 个 数 字 为 此, 程 序 员 就 自 己 写 了 一 个 表, 表 有 两 列, 一 列 是 2/3 的 值, 一 列 是 对 应 的 地 址 如 果 式 子 稍 微 复 杂 点, 那 么 那 个 表 可 能 就 有 个 二 三 十 行, 而 每 写 一 行 代 码 就 要 去 翻 查 相 应 的 地 址, 如 果 来 个 几 万 行 代 码 那 是 人 都 不 能 忍 受 C++ 作 为 高 级 语 言, 很 正 常 地 提 供 了 上 面 问 题 的 解 决 之 道, 就 是 由 编 译 器 来 帮 程 序 员 维 护 那 个 表, 要 查 的 时 候 是 编 译 器 去 查, 这 也 就 是 变 量 的 功 能 变 量 是 一 个 映 射 元 素 上 面 提 到 的 表 由 编 译 器 维 护, 而 表 中 的 每 一 行 都 是 这 个 表 的 一 个 元 素 ( 也 称 记 录 ) 表 有 三 列 : 变 量 名 对 应 地 址 和 相 应 类 型 变 量 名 是 一 个 标 识 符, 因 此 其 命 名 规 则 完 全 按 照 上 一 篇 所 说 的 来 当 要 对 某 块 内 存 写 入 数 据 时, 程 序 员 使 用 相 应 的 变 量 名 进 行 内 存 的 标 识, 而 表 中 的 对 应 地 址 就 记 录 了 这 个 地 址, 进 而 将 程 序 员 给 出 的 变 量 名, 一 个 标 识 符, 映 射 成 一 个 地 址, 因 此 变 量 是 一 个 映 射 元 素 而 相 应 类 型 则 告 诉 编 译 器 应 该 如 何 解 释 此 地 址 所 指 向 的 内 存, 是 2 个 连 续 字 节 还 是 4 个? 是 原 码 记 录 还 是 补 码? 而 变 量 所 对 应 的 地 址 所 标 识 的 内 存 的 内 容 叫 做 此 变 量 的 值 有 如 下 的 变 量 解 释 : 可 变 的 量, 其 相 当 于 一 个 盒 子, 数 字 就 装 在 盒 子 里, 而 变 量 名 就 写 在 盒 子 外 面, 这 样 电 脑 就 知 道 我 们 要 处 理 哪 一 个 盒 子, 且 不 同 的 盒 子 装 不 同 的 东 西, 装 字 符 串 的 盒 子 就 不 能 装 数 字 上 面 就 是 我 第 一 次 学 习 编 程 时, 书 上 写 的 ( 是 BASIC 语 言 ) 对 于 初 学 者 也 许 很 容 易 理 解, 也 不 能 说 错, 但 是 造 成 的 误 解 将 导 致 以 后 的 程 序 编 写 地 千 疮 百 孔 上 面 的 解 释 隐 含 了 一 个 意 思 变 量 是 一 块 内 存 这 是 严 重 错 误 的! 如 果 变 量 是 一 块 内 存, 那 么 C++ 中 著 名 的 引 用 类 型 将 被 弃 置 荒 野 变 量 实 际 并 不 是 一 块 内 存, 只 是 一 个 映 射 元 素, 这 是 致 关 重 要 的 内 存 的 种 类 前 面 已 经 说 了 内 存 是 什 么 及 其 用 处, 但 内 存 是 不 能 随 便 使 用 的, 因 为 操 作 系 统 自 己 也 要 使 用 内 存, 而 且 现 在 的 操 作 系 统 正 常 情 况 下 都 是 多 任 务 操 作 系 统, 即 可 同 时 执 行 多 个 程 序, 即 使 只 有 一 个 CPU 因 此 如 果 不 对 内 存 访 问 加 以 节 制, 可 能 会 破 坏 另 一 个 程 序 的 运 作 比 如 我 在 纸 上 写 了 2/3 的 值, 而 你 未 经 我 同 意 且 未 通 知 我 就 将 那 个 值 擦 掉, 并 写 上 5*2 的 值, 结 果 我 后 面 的 所 有 计 算 也 就 出 错 了 因 此 为 了 使 用 一 块 内 存, 需 要 向 操 作 系 统 申 请, 由 操 作 系 统 统 一 管 理 所 有 程 序 使 用 的 内 存 所 以 为 了 记 录 一 个 long 类 型 的 数 字, 先 向 操 作 系 统 申 请 一 块 连 续 的 4 字 节 长 的 内 存 空 间, 然 后 操 作 系 统 就 会 在 内 存 中 查 看, 看 是 否 还 有 连 续 的 4 个 字 节 长 的 内 存, 如 果 找 到, 则 返 回 此 4 字 节 内 存 的 首 地 址, 然 后 编 译 器 编 译 的 指 令 将 其 记 录 在 前 面 提 到 的 变 量 表 中, 最 后 就 可 以 用 它 记 录 一 些 临 时 计 算 结 果 了

上 面 的 过 程 称 为 要 求 操 作 系 统 分 配 一 块 内 存 这 看 起 来 很 不 错, 但 是 如 果 只 为 了 4 个 字 节 就 要 求 操 作 系 统 搜 索 一 下 内 存 状 况, 那 么 如 果 需 要 100 个 临 时 数 据, 就 要 求 操 作 系 统 分 配 内 存 100 次, 很 明 显 地 效 率 低 下 ( 无 谓 的 99 次 查 看 内 存 状 况 ) 因 此 C++ 发 现 了 这 个 问 题, 并 且 操 作 系 统 也 提 出 了 相 应 的 解 决 方 法, 最 后 提 出 了 如 下 的 解 决 之 道 栈 (Stack) 任 何 程 序 执 行 前, 预 先 分 配 一 固 定 长 度 的 内 存 空 间, 这 块 内 存 空 间 被 称 作 栈 ( 这 种 说 法 并 不 准 确, 但 由 于 实 际 涉 及 到 线 程, 在 此 为 了 不 将 问 题 复 杂 化 才 这 样 说 明 ), 也 被 叫 做 堆 栈 那 么 在 要 求 一 个 4 字 节 内 存 时, 实 际 是 在 这 个 已 分 配 好 的 内 存 空 间 中 获 取 内 存, 即 内 存 的 维 护 工 作 由 程 序 员 自 己 来 做, 即 程 序 员 自 己 判 断 可 以 使 用 哪 些 内 存, 而 不 是 操 作 系 统, 直 到 已 分 配 的 内 存 用 完 很 明 显, 上 面 的 工 作 是 由 编 译 器 来 做 的, 不 用 程 序 员 操 心, 因 此 就 程 序 员 的 角 度 来 看 什 么 事 情 都 没 发 生, 还 是 需 要 像 原 来 那 样 向 操 作 系 统 申 请 内 存, 然 后 再 使 用 但 工 作 只 是 从 操 作 系 统 变 到 程 序 自 己 而 已, 要 维 护 内 存, 依 然 要 耗 费 CPU 的 时 间, 不 过 要 简 单 多 了, 因 为 不 用 标 记 一 块 内 存 是 否 有 人 使 用, 而 专 门 记 录 一 个 地 址 此 地 址 以 上 的 内 存 空 间 就 是 有 人 正 在 使 用 的, 而 此 地 址 以 下 的 内 存 空 间 就 是 无 人 使 用 的 之 所 以 是 以 下 的 空 间 为 无 人 使 用 而 不 是 以 上, 是 当 此 地 址 减 小 到 0 时 就 可 以 知 道 堆 栈 溢 出 了 ( 如 果 你 已 经 有 些 基 础, 请 不 要 把 0 认 为 是 虚 拟 内 存 地 址, 关 于 虚 拟 内 存 将 会 在 C++ 从 零 开 始 ( 十 八 ) 中 进 行 说 明, 这 里 如 此 解 释 只 是 为 了 方 便 理 解 ) 而 且 CPU 还 专 门 对 此 法 提 供 了 支 持, 给 出 了 两 条 指 令, 转 成 汇 编 语 言 就 是 push 和 pop, 表 示 压 栈 和 出 栈, 分 别 减 小 和 增 大 那 个 地 址 而 最 重 要 的 好 处 就 是 由 于 程 序 一 开 始 执 行 时 就 已 经 分 配 了 一 大 块 连 续 内 存, 用 一 个 变 量 记 录 这 块 连 续 内 存 的 首 地 址, 然 后 程 序 中 所 有 用 到 的, 程 序 员 以 为 是 向 操 作 系 统 分 配 的 内 存 都 可 以 通 过 那 个 首 地 址 加 上 相 应 偏 移 来 得 到 正 确 位 置, 而 这 很 明 显 地 由 编 译 器 做 了 因 此 实 际 上 等 同 于 在 编 译 时 期 ( 即 编 译 器 编 译 程 序 的 时 候 ) 就 已 经 分 配 了 内 存 ( 注 意, 实 际 编 译 时 期 是 不 能 分 配 内 存 的, 因 为 分 配 内 存 是 指 程 序 运 行 时 向 操 作 系 统 申 请 内 存, 而 这 里 由 于 使 用 堆 栈, 则 编 译 器 将 生 成 一 些 指 令, 以 使 得 程 序 一 开 始 就 向 操 作 系 统 申 请 内 存, 如 果 失 败 则 立 刻 退 出, 而 如 果 不 退 出 就 表 示 那 些 内 存 已 经 分 配 到 了, 进 而 代 码 中 使 用 首 地 址 加 偏 移 来 使 用 内 存 也 就 是 有 效 的 ), 但 坏 处 也 就 是 只 能 在 编 译 时 期 分 配 内 存 堆 (Heap) 上 面 的 工 作 是 编 译 器 做 的, 即 程 序 员 并 不 参 与 堆 栈 的 维 护 但 上 面 已 经 说 了, 堆 栈 相 当 于 在 编 译 时 期 分 配 内 存, 因 此 一 旦 计 算 好 某 块 内 存 的 偏 移, 则 这 块 内 存 就 只 能 那 么 大, 不 能 变 化 了 ( 如 果 变 化 会 导 致 其 他 内 存 块 的 偏 移 错 误 ) 比 如 要 求 客 户 输 入 定 单 数 据, 可 能 有 10 份 定 单, 也 可 能 有 100 份 定 单, 如 果 一 开 始 就 定 好 了 内 存 大 小, 则 可 能 造 成 不 必 要 的 浪 费, 又 或 者 内 存 不 够 为 了 解 决 上 面 的 问 题,C++ 提 供 了 另 一 个 途 径, 即 允 许 程 序 员 有 两 种 向 操 作 系 统 申 请 内 存 的 方 式 前 一 种 就 是 在 栈 上 分 配, 申 请 的 内 存 大 小 固 定 不 变 后 一 种 是 在 堆 上 分 配, 申 请 的 内 存 大 小 可 以 在 运 行 的 时 候 变 化, 不 是 固 定 不 变 的 那 么 什 么 叫 堆? 在 Windows 操 作 系 统 下, 由 操 作 系 统 分 配 的 内 存 就 叫 做 堆, 而 栈 可 以 认 为 是 在 程 序 开 始 时 就 分 配 的 堆 ( 这 并 不 准 确, 但 为 了 不 复 杂 化 问 题, 故 如 此 说 明 ) 因 此 在 堆 上 就 可 以 分 配 大 小 变 化 的 内 存 块, 因 为 是 运 行 时 期 即 时 分 配 的 内 存, 而 不 是 编 译 时 期 已 计 算 好 大 小 的 内 存 块 变 量 的 定 义 上 面 说 了 那 么 多, 你 可 能 看 得 很 晕, 毕 竟 连 一 个 实 例 都 没 有, 全 是 文 字, 下 面 就 来 帮 助 加 深 对 上 面 的 理 解 定 义 一 个 变 量, 就 是 向 上 面 说 的 由 编 译 器 维 护 的 变 量 表 中 添 加 元 素, 其 语 法 如 下 : long a; 先 写 变 量 的 类 型, 然 后 一 个 或 多 个 空 格 或 制 表 符 (\t) 或 其 它 间 隔 符, 接 着 变 量 的 名 字, 最 后 用 分 号 结 束 要 同 时 定 义 多 个 变 量, 则 各 变 量 间 使 用 逗 号 隔 开, 如 下 : long a, b, c; unsigned short e, a_34c; 上 面 是 两 条 变 量 定 义 语 句, 各 语 句 间 用 分 号 隔 开, 而 各 同 类 型 变 量 间 用 逗 号 隔 开 而 前 面 的 式 子 5+2/3-5*2, 则 如 下 书 写 long a = 2/3, b = 5*2; long c = 5 + a b; 可 以 不 用 再 去 记 那 烦 人 的 地 址 了, 只 需 记 着 a b 这 种 简 单 的 标 识 符 当 然, 上 面 的 式

子 不 一 定 非 要 那 么 写, 也 可 以 写 成 :long c = 5 + 2 / 3 5 * 2; 而 那 些 编 译 器 会 自 动 生 成 并 使 用 ( 实 际 中 编 译 器 由 于 优 化 的 原 因 将 直 接 计 算 出 结 果, 而 不 会 生 成 实 际 的 计 算 代 码 ) 下 面 就 是 问 题 的 关 键, 定 义 变 量 就 是 添 加 一 个 映 射 前 面 已 经 说 了, 这 个 映 射 是 将 变 量 名 和 一 个 地 址 关 联, 因 此 在 定 义 一 个 变 量 时, 编 译 器 为 了 能 将 变 量 名 和 某 个 地 址 对 应 起 来, 帮 程 序 员 在 前 面 提 到 的 栈 上 分 配 了 一 块 内 存, 大 小 就 视 这 个 变 量 类 型 的 大 小 如 上 面 的 a b c 的 大 小 都 是 4 个 字 节, 而 e a_34c 的 大 小 都 是 2 个 字 节 假 设 编 译 器 分 配 的 栈 在 一 开 始 时 的 地 址 是 1000, 并 假 设 变 量 a 所 对 应 的 地 址 是 1000-56, 则 b 所 对 应 的 地 址 就 是 1000-60, 而 c 所 对 应 的 就 是 1000-64,e 对 应 的 是 1000-66,a_34 1000-68 如 果 这 时 b 突 然 不 想 是 4 字 节 了, 而 希 望 是 8 字 节, 则 后 续 的 c e a_34c 都 将 由 于 还 是 原 来 的 偏 移 位 置 而 使 用 了 错 误 的 内 存, 这 也 就 是 为 什 么 栈 上 分 配 的 内 存 必 须 是 固 定 大 小 考 虑 前 面 说 的 红 色 文 字 : 变 量 实 际 并 不 是 一 块 内 存, 只 是 一 个 映 射 元 素 可 是 只 要 定 义 一 个 变 量, 就 会 相 应 地 得 到 一 块 内 存, 为 什 么 不 说 变 量 就 是 一 块 内 存? 上 面 定 义 变 量 时 之 所 以 会 分 配 一 块 内 存 是 因 为 变 量 是 一 个 映 射 元 素, 需 要 一 个 对 应 地 址, 因 此 才 在 栈 上 分 配 了 一 块 内 存, 并 将 其 地 址 记 录 到 变 量 表 中 但 是 变 量 是 可 以 有 别 名 的, 即 另 一 个 名 字 这 个 说 法 是 不 准 确 的, 应 该 是 变 量 所 对 应 的 内 存 块 有 另 一 个 名 字, 而 不 止 是 这 个 变 量 的 名 字 为 什 么 要 有 别 名? 这 是 语 义 的 需 要, 表 示 既 是 什 么 又 是 什 么 比 如 一 块 内 存, 里 面 记 录 了 老 板 的 信 息, 因 此 起 名 为 Boss, 但 是 老 板 又 是 另 一 家 公 司 的 行 政 经 理, 故 变 量 名 应 该 为 Manager, 而 在 程 序 中 有 段 代 码 是 老 板 的 公 司 相 关 的, 而 另 一 段 是 老 板 所 在 公 司 相 关 的, 在 这 两 段 程 序 中 都 要 使 用 到 老 板 的 信 息, 那 到 底 是 使 用 Boss 还 是 Manager? 其 实 使 用 什 么 都 不 会 对 最 终 生 成 的 机 器 代 码 产 生 什 么 影 响, 但 此 处 出 于 语 义 的 需 要 就 应 该 使 用 别 名, 以 期 从 代 码 上 表 现 出 所 编 写 程 序 的 意 思 在 C++ 中, 为 了 支 持 变 量 别 名, 提 供 了 引 用 变 量 这 个 概 念 要 定 义 一 个 引 用 变 量, 在 定 义 变 量 时, 在 变 量 名 的 前 面 加 一 个 &, 如 下 书 写 : long a; long &a1 = a, &a2 = a, &a3 = a2; 上 面 的 a1 a2 a3 都 是 a 所 对 应 的 内 存 块 的 别 名 这 里 在 定 义 变 量 a 时 就 在 栈 上 分 配 了 一 块 4 字 节 内 存, 而 在 定 义 a1 时 却 没 有 分 配 任 何 内 存, 直 接 将 变 量 a 所 映 射 的 地 址 作 为 变 量 a1 的 映 射 地 址, 进 而 形 成 对 定 义 a 时 所 分 配 的 内 存 的 别 名 因 此 上 面 的 Boss 和 Manager, 应 该 如 下 ( 其 中 Person 是 一 个 结 构 或 类 或 其 他 什 么 自 定 义 类 型, 这 将 在 后 继 的 文 章 中 陆 续 说 明 ): Person Boss; Person &Manager = Boss; 由 于 变 量 一 旦 定 义 就 不 能 改 变 ( 指 前 面 说 的 变 量 表 里 的 内 容, 不 是 变 量 的 值 ), 直 到 其 被 删 除, 所 以 上 面 在 定 义 引 用 变 量 的 时 候 必 须 给 出 欲 别 名 的 变 量 以 初 始 化 前 面 的 变 量 表, 否 则 编 译 器 编 译 时 将 报 错 现 在 应 该 就 更 能 理 解 前 面 关 于 变 量 的 红 字 的 意 思 了 并 不 是 每 个 变 量 定 义 时 都 会 分 配 内 存 空 间 的 而 关 于 如 何 在 堆 上 分 配 内 存, 将 在 介 绍 完 指 针 后 予 以 说 明, 并 进 而 说 明 上 一 篇 遗 留 下 来 的 关 于 字 符 串 的 问 题

C++ 从 零 开 始 ( 四 ) 赋 值 操 作 符 本 篇 是 C++ 从 零 开 始 ( 二 ) 的 延 续, 说 明 C++ 从 零 开 始 ( 二 ) 中 遗 留 下 来 的 关 于 表 达 式 的 内 容, 并 为 下 篇 指 针 的 运 用 做 一 点 铺 垫 虽 然 上 篇 已 经 说 明 了 变 量 是 什 么, 但 对 于 变 量 最 关 键 的 东 西 却 由 于 篇 幅 限 制 而 没 有 说 明, 下 面 先 说 明 如 何 访 问 内 存 赋 值 语 句 前 面 已 经 说 明, 要 访 问 内 存, 就 需 要 相 应 的 地 址 以 表 明 访 问 哪 块 内 存, 而 变 量 是 一 个 映 射, 因 此 变 量 名 就 相 当 于 一 个 地 址 对 于 内 存 的 操 作, 在 一 般 情 况 下 就 只 有 读 取 内 存 中 的 数 值 和 将 数 值 写 入 内 存 ( 不 考 虑 分 配 和 释 放 内 存 ), 在 C++ 中, 为 了 将 一 数 值 写 入 某 变 量 对 应 的 地 址 所 标 识 的 内 存 中 ( 出 于 简 便, 以 后 称 变 量 a 对 应 的 地 址 为 变 量 a 的 地 址, 而 直 接 称 变 量 a 的 地 址 所 标 识 的 内 存 为 变 量 a), 只 需 先 书 写 变 量 名, 后 接 =, 再 接 欲 写 入 的 数 字 ( 关 于 数 字, 请 参 考 C++ 从 零 开 始 ( 二 ) ) 以 及 分 号 如 下 : a = 10.0f; b = 34; 由 于 接 的 是 数 字, 因 此 就 可 以 接 表 达 式 并 由 编 译 器 生 成 计 算 相 应 表 达 式 所 需 的 代 码, 也 就 可 如 下 : c = a / b * 120.4f; 上 句 编 译 器 将 会 生 成 进 行 除 法 和 乘 法 计 算 的 CPU 指 令, 在 计 算 完 毕 后 ( 也 就 是 求 得 表 达 式 a / b * 120.4f 的 值 了 后 ), 也 会 同 时 生 成 将 计 算 结 果 放 到 变 量 c 中 去 的 CPU 指 令, 这 就 是 语 句 的 基 本 作 用 ( 对 于 语 句, 在 C++ 从 零 开 始 ( 六 ) 中 会 详 细 说 明 ) 上 面 在 书 写 赋 值 语 句 时, 应 该 确 保 此 语 句 之 前 已 经 将 使 用 到 的 变 量 定 义 过, 这 样 编 译 器 才 能 在 生 成 赋 值 用 的 CPU 指 令 时 查 找 到 相 应 变 量 的 地 址, 进 而 完 成 CPU 指 令 的 生 成 如 上 面 的 a 和 b, 就 需 要 在 书 写 上 面 语 句 前 先 书 写 类 似 下 面 的 变 量 定 义 : float a; long b; 直 接 书 写 变 量 名 也 是 一 条 语 句, 其 导 致 编 译 器 生 成 一 条 读 取 相 应 变 量 的 内 容 的 语 句 即 可 以 如 下 书 写 : a; 上 面 将 生 成 一 条 读 取 内 存 的 语 句, 即 使 从 内 存 中 读 出 来 的 数 字 没 有 任 何 应 用 ( 当 然, 如 果 编 译 器 开 了 优 化 选 项, 则 上 面 的 语 句 将 不 会 生 成 任 何 代 码 ) 从 这 一 点 以 及 上 面 的 c = a / b * 120.4f; 语 句 中, 都 可 以 看 出 一 点 变 量 是 可 以 返 回 数 字 的 而 变 量 返 回 的 数 字 就 是 按 照 变 量 的 类 型 来 解 释 变 量 对 应 内 存 中 的 内 容 所 得 到 的 数 字 这 句 话 也 许 不 是 那 么 容 易 理 解, 在 看 过 后 面 的 类 型 转 换 一 节 后 应 该 就 可 以 理 解 了 因 此 为 了 将 数 据 写 入 一 块 内 存, 使 用 赋 值 语 句 ( 即 等 号 ); 要 读 取 一 块 内 存, 书 写 标 识 内 存 的 变 量 名 所 以 就 可 以 这 样 书 写 :a = a + 3; 假 设 a 原 来 的 值 为 1, 则 上 面 的 赋 值 语 句 将 a 的 值 取 出 来, 加 上 3, 得 到 结 果 4, 将 4 再 写 入 a 中 去 由 于 C++ 使 用 = 来 代 表 赋 值 语 句, 很 容 易 使 人 和 数 学 中 的 等 号 混 淆 起 来, 这 点 应 注 意 而 如 上 的 float a; 语 句, 当 还 未 对 变 量 进 行 任 何 赋 值 操 作 时,a 的 值 是 什 么? 上 帝 才 知 道 当 时 的 a 的 内 容 是 什 么 ( 对 于 VC 编 译 器, 在 开 启 了 调 试 选 项 时, 将 会 用 0xCCCCCCCC 填 充 这 些 未 初 始 化 内 存 ), 就 用 IEEE 的 real*4 格 式 来 解 释 它 并 得 到 相 应 的 一 个 数 字, 也 就 是 a 的 值 因 此 应 在 变 量 定 义 的 时 候 就 进 行 赋 值 ( 但 是 会 有 性 能 上 的 影 响, 不 过 很 小 ), 以 初 始 化 变 量 而 防 止 出 现 莫 名 其 妙 的 值, 如 :float a = 0.0f; 赋 值 操 作 符 上 面 的 a = a + 3; 的 意 思 就 是 让 a 的 值 增 加 3 在 C++ 中, 对 于 这 种 情 况 给 出 了 一 种 简 写 方 案, 即 前 面 的 语 句 可 以 写 成 :a += 3; 应 当 注 意 这 两 条 语 句 从 逻 辑 上 讲 都 是 使 变 量 a 的 值 增 3, 但 是 它 们 实 际 是 有 区 别 的, 后 者 可 以 被 编 译 成 优 化 的 代 码, 因 为 其 意 思 是 使 某 一 块 内 存 的 值 增 加 一 定 数 量, 而 前 者 是 将 一 个 数 字 写 入 到 某 块 内 存 中 所 以 如 果 可 能, 应 尽 量

使 用 后 者, 即 a += 3; 这 种 语 句 可 以 让 编 译 器 进 行 一 定 的 优 化 ( 但 由 于 现 在 的 编 译 器 都 非 常 智 能, 能 够 发 现 a = a + 3; 是 对 一 块 内 存 的 增 值 操 作 而 不 是 一 块 内 存 的 赋 值 操 作, 因 此 上 面 两 条 语 句 实 际 上 可 以 认 为 完 全 相 同, 仅 仅 只 具 有 简 写 的 功 能 了 ) 对 于 上 面 的 情 况, 也 可 以 应 用 在 减 法 乘 法 等 二 元 非 逻 辑 操 作 符 ( 不 是 逻 辑 值 操 作 符, 即 不 能 a &&= 3;) 上, 如 :a *= 3; a -= 4; a = 34; a >> 除 了 上 面 的 简 写 外,C++ 还 提 供 了 一 种 简 写 方 式, 即 a++;, 其 逻 辑 上 等 同 于 a += 1; 同 上, 在 电 脑 编 程 中, 加 一 和 减 一 是 经 常 用 到 的, 因 此 CPU 专 门 提 供 了 两 条 指 令 来 进 行 加 一 和 减 一 操 作 ( 转 成 汇 编 语 言 就 是 Inc 和 Dec), 但 速 度 比 直 接 通 过 加 法 或 减 法 指 令 来 执 行 要 快 得 多 为 此 C++ 中 也 就 提 供 了 ++ 和 操 作 符 来 对 应 Inc 和 Dec 所 以 a++; 虽 然 逻 辑 上 和 a = a + 1; 等 效, 实 际 由 于 编 译 器 可 能 做 出 的 优 化 处 理 而 不 同, 但 还 是 如 上, 由 于 编 译 器 的 智 能 化, 其 是 有 可 能 看 出 a = a + 1; 可 以 编 译 成 Inc 指 令 进 而 即 使 没 有 使 用 a++; 却 也 依 然 可 以 得 到 优 化 的 代 码, 这 样 a++; 将 只 剩 下 简 写 的 意 义 而 已 应 当 注 意 一 点,a = 3; 这 句 语 句 也 将 返 回 一 个 数 字, 也 就 是 在 a 被 赋 完 值 后 a 的 值 由 于 其 可 以 返 回 数 字, 按 照 C++ 从 零 开 始 ( 二 ) 中 所 说, = 就 属 于 操 作 符, 也 就 可 以 如 下 书 写 : c = 4 + ( a = 3 ); 之 所 以 打 括 号 是 因 为 = 的 优 先 级 较 + 低, 而 更 常 见 和 正 常 的 应 用 是 :c = a = 3; 应 该 注 意 上 面 并 不 是 将 c 和 a 赋 值 为 3, 而 是 在 a 被 赋 值 为 3 后 再 将 a 赋 值 给 c, 虽 然 最 后 结 果 和 c a 都 赋 值 为 3 是 一 样 的, 但 不 应 该 这 样 理 解 由 于 a++; 表 示 的 就 是 a += 1; 就 是 a = a + 1;, 因 此 a++; 也 将 返 回 一 个 数 字 也 由 于 这 个 原 因,C++ 又 提 供 了 另 一 个 简 写 方 式,+ +a; 假 设 a 为 1, 则 a++; 将 先 返 回 a 的 值,1, 然 后 再 将 a 的 值 加 一 ; 而 ++a; 先 将 a 的 值 加 一, 再 返 回 a 的 值,2 而 a 和 a 也 是 如 此, 只 不 过 是 减 一 罢 了 上 面 的 变 量 a 按 照 最 上 面 的 变 量 定 义, 是 float 类 型 的 变 量, 对 它 使 用 ++ 操 作 符 并 不 能 得 到 预 想 的 优 化, 因 为 float 类 型 是 浮 点 类 型, 其 是 使 用 IEEE 的 real*4 格 式 来 表 示 数 字 的, 而 不 是 二 进 制 原 码 或 补 码, 而 前 面 提 到 的 Inc 和 Dec 指 令 都 是 出 于 二 进 制 的 表 示 优 点 来 进 行 快 速 增 一 和 减 一, 所 以 如 果 对 浮 点 类 型 的 变 量 运 用 ++ 操 作 符, 将 完 全 只 是 简 写, 没 有 任 何 的 优 化 效 果 ( 当 然, 如 果 CPU 提 供 了 新 的 指 令 集, 如 MMX 等, 以 对 real*4 格 式 进 行 快 速 增 一 和 减 一 操 作, 且 编 译 器 支 持 相 应 指 令 集, 则 还 是 可 以 产 生 优 化 效 果 的 ) 赋 值 操 作 符 的 返 回 值 在 进 一 步 了 解 ++a 和 a++ 的 区 别 前, 先 来 了 解 何 谓 操 作 符 的 计 算 (Evaluate) 操 作 符 就 是 将 给 定 的 数 字 做 一 些 处 理, 然 后 返 回 一 个 数 字 而 操 作 符 的 计 算 也 就 是 执 行 操 作 符 的 处 理, 并 返 回 值 前 面 已 经 知 道, 操 作 符 是 个 符 号, 其 一 侧 或 两 侧 都 可 以 接 数 字, 也 就 是 再 接 其 他 操 作 符, 而 又 由 于 赋 值 操 作 符 也 属 于 一 种 操 作 符, 因 此 操 作 符 的 执 行 顺 序 变 得 相 当 重 要 对 于 a + b + c, 将 先 执 行 a + b, 再 执 行 ( a + b ) + c 的 操 作 那 么 如 下, 假 设 a 之 前 为 1: c = ( a *= 2 ) + ( a += 3 ); 上 句 执 行 后 a 为 5 而 c = ( a += 3 ) + ( a *= 2 ); 执 行 后, 可 能 会 大 大 的 出 乎 你 的 意 料 前 者 的 c 为 10, 而 后 者 的 c 为 16 上 面 其 实 是 一 个 障 眼 法, 其 中 的 + 没 有 任 何 意 义, 即 之 所 以 会 从 左 向 右 执 行 并 不 是 因 为 + 的 缘 故, 而 是 因 为 ( a *= 2 ) 和 ( a += 3 ) 的 优 先 级 相 同, 而 按 照 () 算 顺 序, 是 从 左 向 右 来 计 算 的 但 为 什 么 c 的 值 不 是 预 想 的 2 + 5 和 4 + 8 呢? 因 为 赋 值 操 作 符 的 返 回 值 的 关 系 赋 值 操 作 符 返 回 的 数 字 不 是 变 量 的 值, 而 是 变 量 对 应 的 地 址 这 很 重 要 前 面 说 过, 光 写 一 个 变 量 名 就 会 返 回 相 应 变 量 的 值, 那 是 因 为 变 量 是 一 个 映 射, 变 量 名 就 等 同 于 一 个 地 址 C++ 中 将 数 字 看 作 一 个 很 特 殊 的 操 作 符, 即 任 何 一 个 数 字 都 是 一 个 操 作 符 而 地 址 就 和 长 整 型 单 精 度 浮 点 数 这 类 一 样, 是 数 字 的 一 种 类 型 当 一 个 数 字 是 地 址 类 型 时, 作 为 操 作 符, 其 没 有 要 操 作 的 数 字, 仅 仅 返 回 将 此 数 字 看 作 地 址 而 标 识 的 内 存 中 的 内 容 ( 用 这 个 地 址 的 类 型 来 解 释 ) 地 址 可 以 通 过 多 种 途 径 得 到, 如 上 面 光 写 一 个 变 量 名 就 可 以 得

到 其 对 应 的 地 址, 而 得 到 的 地 址 的 类 型 也 就 是 相 应 的 变 量 的 类 型 如 果 这 句 话 不 能 理 解, 在 看 过 下 面 的 类 型 转 换 一 节 后 应 该 就 能 了 解 了 所 以 前 面 的 c = ( a += 3 ) + ( a *= 2 );, 由 于 () 的 参 了 两 个 赋 值 操 作 符, 然 后 两 个 赋 值 操 作 符 都 返 回 a 的 地 址, 然 后 计 算 + 的 值, 分 别 计 算 两 边 的 数 字 a 的 地 址 (a 的 地 址 也 是 一 个 操 作 符 ), 也 就 是 已 经 执 行 过 两 次 赋 值 操 作 的 a 的 值, 得 8, 故 最 后 的 c 为 16 而 另 一 个 也 由 于 同 样 的 原 因 使 得 c 为 10 现 在 考 虑 操 作 符 的 计 算 顺 序 当 同 时 出 现 了 几 个 优 先 级 相 同 的 操 作 符 时, 不 同 的 操 作 符 具 有 不 同 的 计 算 顺 序 前 面 的 () 以 及 - * 等 这 类 二 元 操 作 符 的 计 算 顺 序 都 是 从 左 向 右 计 算, 而! 负 号 - 等 前 面 介 绍 过 的 一 元 操 作 符 都 是 从 右 向 左 计 算 的, 如 :!-!!a;, 假 设 a 为 3 先 计 算 从 左 朝 右 数 第 三 个! 的 值, 导 致 计 算 a 的 地 址 的 值, 得 3; 然 后 逻 辑 取 反 得 0, 接 着 再 计 算 第 二 个! 的 值, 逻 辑 取 反 后 得 1, 再 计 算 负 号 - 的 值, 得 -1, 最 后 计 算 第 一 个! 的 值, 得 0 赋 值 操 作 符 都 是 从 右 向 左 计 算 的, 除 了 后 缀 ++ 和 后 缀 ( 即 上 面 的 a++ 和 a--) 因 此 上 面 的 c = a = 3;, 因 为 两 个 = 优 先 级 相 同, 从 右 向 左 计 算, 先 计 算 a = 3 的 值, 返 回 a 对 应 的 地 址, 然 后 计 算 返 回 的 地 址 而 得 到 值 3, 再 计 算 c = ( a = 3 ), 将 3 写 入 c 而 不 是 从 左 向 右 计 算, 即 先 计 算 c = a, 返 回 c 的 地 址, 然 后 再 计 算 第 二 个 =, 将 3 写 入 c, 这 样 a 就 没 有 被 赋 值 而 出 现 问 题 又 : a = 1; c = 2; c *= a += 4; 由 于 *= 和 += 的 优 先 级 相 同, 从 右 向 左 计 算 先 计 算 a += 4, 得 a 为 5, 然 后 返 回 a 的 地 址, 再 计 算 a 的 地 址 得 a 的 值 5, 计 算 *= 以 使 得 c 的 值 为 10 因 此 按 照 前 面 所 说,++a 将 返 回 a 的 地 址, 而 a++ 也 因 为 是 赋 值 操 作 符 而 必 须 返 回 一 个 地 址, 但 很 明 显 地 不 能 是 a 的 地 址 了, 因 此 编 译 器 将 编 写 代 码 以 从 栈 中 分 配 一 块 和 a 同 样 大 小 的 内 存, 并 将 a 的 值 复 制 到 这 块 临 时 内 存 中, 然 后 返 回 这 块 临 时 内 存 的 地 址 由 于 这 块 临 时 内 存 是 因 为 编 译 器 的 需 要 而 分 配 的, 与 程 序 员 完 全 没 有 关 系, 因 此 程 序 员 是 不 应 该 也 不 能 写 这 块 临 时 内 存 的 ( 因 为 编 译 器 负 责 编 译 代 码, 如 果 程 序 员 欲 访 问 这 块 内 存, 编 译 器 将 报 错 ), 但 可 以 读 取 它 的 值, 这 也 是 返 回 地 址 的 主 要 目 的 所 以 如 下 的 语 句 没 有 问 题 : ( ++a ) = a += 34; 但 ( a++ ) = a += 34; 就 会 在 编 译 时 报 错, 因 为 a++ 返 回 的 地 址 所 标 识 的 内 存 译 器 负 责 处 理, 程 序 员 只 能 获 得 其 值 而 已 a++ 的 意 思 是 先 返 回 a 的 值, 也 就 是 上 面 说 的 临 时 内 存 的 地 址, 然 后 再 将 变 量 的 值 加 一 如 果 同 时 出 现 多 个 a++, 那 么 每 个 a++ 都 需 要 分 配 一 块 临 时 内 存 ( 注 意 前 面 c = ( a += 3 ) + ( a *= 2 ); 的 说 明 ), 那 么 将 有 点 糟 糕, 而 且 a++ 的 意 思 是 先 返 回 a 的 值, 那 么 到 是 什 么 时 候 的 a 的 值 呢? 在 VC 中, 当 表 达 式 中 出 现 后 缀 ++ 或 后 缀 时, 只 分 配 一 块 临 时 内 存, 然 后 所 有 的 后 缀 ++ 或 后 缀 都 返 回 这 个 临 时 内 存 的 地 址, 然 后 在 所 有 的 可 以 计 算 的 其 他 操 作 符 的 值 计 算 完 毕 后, 再 将 对 应 变 量 的 值 写 入 到 临 时 内 存 中, 计 算 表 达 式 的 值, 最 后 将 对 应 变 量 的 值 加 一 或 减 一 因 此 :a = 1; c = ( a++ ) + ( a++ ); 执 行 后,c 的 值 为 2, 而 a = 1; b = 1; c = ( ++a ) + ( a++ ) + ( b + ); 执 行 时, 先 分 配 临 时 内 存, 然 后 由 于 5 个 (), 其 计 算 顺 序 是 从 左 向 右, 计 算 ++a 的 值, 返 回 增 一 后 的 a 的 地 址,a 的 值 为 2 计 算 a++ 的 值, 返 回 临 时 内 存 的 地 址,a 的 值 仍 为 2 计 算 b *= a++ 中 的 a++, 返 回 临 时 内 存 的 地 址,a 的 值 仍 为 2 计 算 b *= a++ 中 的 *=, 将 a 的 值 写 入 临 时 内 存, 计 算 得 b 的 值 为 2, 返 回 b 的 地 址 计 算 a *= 2 的 值, 返 回 a 的 地 址,a 的 值 为 4 计 算 a *= a++ 中 的 a++, 返 回 临 时 内 存 的 地 址,a 的 值 仍 为 4 计 算 a *= a++ 中 的 *=, 将 a 的 值 写 入 临 时 内 存, 返 回 a 的 地 址,a 的 值 为 16 计 算 剩 下 的 +, 为 了 进 行 计 算, 将 a 的 值 写 入 临 时 内 存, 得 值 16 + 16 + 2 + 1 16 为 66, 写 入 c 中 计 算 三 个 a++ 欠 下 的 加 一,a 最 后 变 为 19 上 面 说 了 那 么 多, 无 非 只 是 想 告 诫 你 在 表 达 式 中 运 用 赋 值 操 作 符 是 不 被 推 崇 的 因 为 其 不 符 合 平 常 的 数 学 表 达 式 的 习 惯, 且 计 算 顺 序 很 容 易 搞 混 如 果 有 多 个 ++ 操 作 符, 最 好 还 是 将 表 达 式 分 开, 否 则 很 容 易 导 致 错 误 的 计 算 顺 序 而 计 算 错 误 并 且 导 致 计 算 顺 序 混 乱 的 还 不 止 上 面 的 a++ 就 完 了, 为 了 让 你 更 加 地 重 视 前 面 的 红 字, 下 面 将 介 绍 更 令

人 火 大 的 东 西, 如 果 你 已 经 同 意 上 面 的 红 字, 则 下 面 这 一 节 完 全 可 以 跳 过, 其 对 编 程 来 讲 可 以 认 为 根 本 没 有 任 何 意 义 ( 要 不 是 为 了 写 这 篇 文 章, 我 都 不 知 道 它 的 存 在 ) 序 列 点 (Sequence Point) 和 附 加 效 果 (Side Effect) 在 计 算 c = a++ 时, 当 c 的 值 计 算 (Evaluate) 出 来 时,a 的 值 也 增 加 了 一,a 的 值 加 是 计 算 前 面 表 达 式 的 附 加 效 果 有 什 么 问 题? 它 可 能 影 响 表 达 式 的 计 算 结 果 对 于 a = 0; b = 1; ( a *= 2 ) && ( b += 2 ); 右 计 算, 计 算 *= 而 返 回 a 的 地 址, 再 计 算 += 而 返 回 b 的 地 址, 最 后 由 于 a 的 值 为 0 而 返 回 逻 辑 假 很 正 常, 但 效 率 低 了 点 如 果 && 左 边 的 数 字 已 经 是 0 了, 则 不 再 需 要 计 算 右 边 的 式 子 同 样, 如 果 左 边 的 数 字 已 经 非 零 了, 也 不 需 要 再 计 算 右 边 的 数 字 因 为 && 和 都 是 数 学 上 的, 数 学 上 不 管 先 计 算 加 号 左 边 的 值 还 是 右 边 的 值, 结 果 都 不 会 改 变, 因 此 && 和 才 会 做 刚 才 的 解 释 这 也 是 C++ 保 证 的, 既 满 足 数 学 的 定 义, 又 能 提 供 优 化 的 途 径 ( && 和 右 边 的 数 字 不 用 计 算 了 ) 因 此 上 面 的 式 子 就 会 被 解 释 成 如 果 a 在 自 乘 了 2 后 的 值 为 0, 则 b 就 不 用 再 自 增 2 了 这 很 明 显 地 违 背 了 我 们 的 初 衷, 认 为 b 无 论 如 何 都 会 被 自 增 2 的 但 是 C++ 却 这 样 保 证, 不 仅 仅 是 因 为 数 学 的 定 义, 还 由 于 代 码 生 成 的 优 化 但 是 按 照 操 作 符 的 优 先 级 进 行 计 算, 上 面 的 b += 2 依 旧 会 被 执 行 的 ( 这 也 正 是 我 们 会 书 写 上 面 代 码 的 原 因 ) 为 了 实 现 当 a 为 0 时 b += 2 不 会 被 计 算,C++ 提 出 了 序 列 点 的 概 念 序 列 点 是 一 些 特 殊 位 置, 由 C++ 强 行 定 义 (C++ 并 未 给 出 序 列 点 的 定 义, 因 此 不 同 的 编 译 器 可 能 给 出 不 同 的 序 列 点 定 义,VC 是 按 照 C 语 言 定 义 的 序 列 点 ) 当 在 进 行 操 作 符 的 计 算 时, 如 果 遇 到 序 列 点, 则 序 列 点 处 的 值 必 须 被 优 先 计 算, 以 保 证 一 些 特 殊 用 途, 如 上 面 的 保 证 当 a 为 0 时 不 计 算 b += 2, 并 且 序 列 点 相 关 的 操 作 符 ( 如 前 面 的 && 和 ) 也 将 被 计 算 完 毕, 然 后 才 恢 复 正 常 的 计 算 && 的 左 边 数 字 的 计 算 就 是 一 个 序 列 点, 而 的 左 边 数 字 的 计 算 也 是 C++ 定 义 了 多 个 序 列 点, 包 括 条 件 语 句 函 数 参 数 等 条 件 下 的 表 达 式 计 算, 在 此, 不 需 要 具 体 了 解 有 哪 些 序 列 点, 只 需 要 知 道 由 于 序 列 点 的 存 在 而 可 能 导 致 赋 值 操 作 符 的 计 算 出 乎 意 料 下 面 就 来 分 析 一 个 例 子 : a = 0; b = 1; ( a *= 2 ) && ( b += ++a ); 按 照 优 先 级 的 顺 序, 编 译 器 发 现 要 先 计 算 a *= 2, 再 计 算 ++a, 接 着 +=, 最 后 计 算 && 然 后 编 译 器 发 现 这 个 计 算 过 程 中, 出 现 了 && 左 边 的 数 字 这 个 序 列 点, 其 要 保 证 被 优 先 计 算, 这 样 就 有 可 能 不 用 计 算 b += ++a 了 所 以 编 译 器 先 计 算 && 的 数 字, 通 过 上 面 的 计 算 过 程, 编 译 器 发 现 就 要 计 算 a *= 2 才 能 得 到 && 左 边 的 数 字, 因 此 将 先 计 算 a *= 2, 返 回 a 的 地 址, 然 后 计 算 && 左 边 的 数 字, 得 a 的 值 为 0, 因 此 就 不 计 算 b += ++a 了 而 不 是 最 开 始 想 象 的 由 于 优 先 级 的 关 系 先 将 a 加 一 后 再 进 行 a 的 计 算, 以 返 回 1 所 以 上 面 计 算 完 毕 后,a 为 0,b 为 1, 返 回 0, 表 示 逻 辑 假 因 此 序 列 点 的 出 现 是 为 了 保 证 一 些 特 殊 规 则 的 出 现, 如 上 面 的 && 和 再 考 虑, 操 作 符, 其 操 作 是 计 算 两 边 的 值, 然 后 返 回 右 边 的 数 字, 即 :a, b + 3 将 返 回 b + 3 的 值, 但 是 a 依 旧 会 被 计 算 由 于, 的 优 先 级 是 最 低 的 ( 但 高 于 前 面 提 到 的 数 字 操 作 符 ), 因 此 如 果 a = 3, 4;, 那 么 a 将 为 3 而 不 是 4, 因 为 先 计 算 =, 返 回 a 的 地 址 后 再 计 算, 又 : a = 1; b = 0; b = ( a += 2 ) + ( ( a *= 由 于 && 左 边 数 字 是 一 个 序 列 点, 因 此 先 计 算 a *= 2, b 的 值, 但 根 据, 的 返 回 值 定 义, 其 只 返 回 右 边 的 数 字, 因 此 不 计 算 a *= 2 而 直 接 计 算 b = a 1 得 0, && 就 返 回 了, 但 是 a *= 2 就 没 有 被 计 算 而 导 致 a 的 值 依 旧 为 1, 这 违 背 了, 的 定 义 为 了 消 除 这 一 点 ( 当 然 可 能 还 有 其 他 应 用, 的 情 况 ),C++ 也 将, 的 左 边 数 字 定 为 了 序 列 点, 即 一 定 会 优 先 执 行, 左 边 的 数 字 以 保 证, 的 定 义 计 算 两 边 的 数 字 所 以 上 面 就 由 于, 左 边 数 字 这 个 序 列 点 而 导 致 a *= 2 被 优 先 执 行, 并 导 致 b 为 1, 因 此 由 于 && 是 序 列 点 且 其 左 边 数 字 非 零 而 必 须 计 算 完 右 边 数 字 后 才 恢 复 正 常 优 先 级, 而 计 算 c = a, 得 2, 最 后 才 恢 复 正 常 优 先 级 顺 序, 执 行 a += 2 和 + 结 果 就 a 为 4,c 为 2,b 为 5 所 以 前 面 的 a = 3, 4; 其 实 就 应 该 是 编 译 器 先 发 现, 这 个 序 列 点, 而 发 现 要 计 算, 左 边 的 值, 必 须 先 计 算 出 a = 3, 因 此 才 先 计 算 a = 3 以 至 于 感 觉 序 列 点 好 像 没 有 发

生 作 用 下 面 的 式 子 请 自 行 分 析, 执 行 后 a 为 4, 但 如 果 将 其 中 的, 换 成 &&,a 为 2 a = 1; b = ( a *= 2 ) + ( ( a *= 3 ), ( 如 果 上 面 你 看 得 很 晕, 没 关 系, 因 为 上 面 的 内 容 根 本 可 以 认 为 毫 无 意 义, 写 在 这 里 也 只 是 为 了 进 一 步 向 你 证 明, 在 表 达 式 中 运 用 赋 值 运 算 符 是 不 好 的, 即 使 它 可 能 让 你 写 出 看 起 来 简 练 的 语 句, 但 它 也 使 代 码 的 可 维 护 性 降 低 类 型 转 换 在 C++ 从 零 开 始 ( 二 ) 中 说 过, 数 字 可 以 是 浮 点 数 或 是 整 型 数 或 其 他, 也 就 是 说 数 字 是 具 有 类 型 的 注 意 C++ 从 零 开 始 ( 三 ) 中 对 类 型 的 解 释, 类 型 只 是 说 明 如 何 解 释 状 态, 而 在 前 面 已 经 说 过, 出 于 方 便, 使 用 二 进 制 数 来 表 示 状 态, 因 此 可 以 说 类 型 是 用 于 告 诉 编 译 器 如 何 解 释 二 进 制 数 的 所 以, 一 个 长 整 型 数 字 是 告 诉 编 译 器 将 得 到 的 二 进 制 数 表 示 的 状 态 按 照 二 进 制 补 码 的 格 式 来 解 释 以 得 到 一 个 数 值, 而 一 个 单 精 度 浮 点 数 就 是 告 诉 编 译 器 将 得 到 的 二 进 制 数 表 示 的 状 态 按 照 IEEE 的 real*4 的 格 式 来 解 释 以 得 到 一 个 是 小 数 的 数 值 很 明 显, 同 样 的 二 进 制 数 表 示 的 状 态, 按 照 不 同 的 类 型 进 行 解 释 将 得 到 不 同 的 数 值, 那 么 编 译 器 如 何 知 道 应 该 使 用 什 么 类 型 来 进 行 二 进 制 数 的 解 释? 前 面 已 经 说 过, 数 字 是 一 种 很 特 殊 的 操 作 符, 其 没 有 操 作 数, 仅 仅 返 回 由 其 类 型 而 定 的 二 进 制 数 表 示 的 状 态 ( 以 后 为 了 方 便, 将 二 进 制 数 表 示 的 状 态 称 作 二 进 制 数 ) 而 操 作 符 就 是 执 行 指 令 并 返 回 数 字, 因 此 所 有 的 操 作 符 到 最 后 一 定 执 行 的 是 返 回 一 个 二 进 制 数 这 点 很 重 要, 对 于 后 面 指 针 的 理 解 有 着 重 要 的 意 义 先 看 15;, 这 是 一 条 语 句, 因 为 15 是 一 个 数 字 所 以 15 被 认 为 是 char 类 型 的 数 字 ( 因 为 其 小 于 128, 没 超 出 char 的 表 示 范 围 ), 将 返 回 一 个 8 位 长 的 二 进 制 数, 此 二 进 制 数 按 照 补 码 格 式 编 写, 为 00001111 再 看 15.0f, 同 上, 其 由 于 接 了 f 这 个 后 缀 而 被 认 为 是 float 类 型 的 数 字, 将 返 回 一 个 32 位 长 的 二 进 制 数, 此 二 进 制 数 按 照 IEEE 的 real*4 格 式 编 写, 为 1000001011100000000000000000000 虽 然 上 面 15 和 15.0f 的 数 值 相 等, 但 由 于 是 不 同 的 类 型 导 致 了 使 用 不 同 的 格 式 来 表 示, 甚 至 连 表 示 用 的 二 进 制 数 的 长 度 都 不 相 同 因 此 如 果 书 写 15.0f == 15; 将 返 回 0, 表 示 逻 辑 假 但 实 际 却 返 回 1, 为 什 么? 上 面 既 然 15 和 15.0f 被 表 示 成 完 全 不 同 的 两 个 二 进 制 数, 但 我 们 又 认 为 15 和 15.0f 是 相 等 的, 但 它 们 的 二 进 制 表 示 不 同, 怎 么 办? 将 表 示 15.0f 的 二 进 制 数 用 IEEE 的 real*4 格 式 解 释 出 15 这 个 数 值, 然 后 再 将 其 按 8 位 二 进 制 补 码 格 式 编 写 出 二 进 制 数, 再 与 原 来 的 表 示 15 的 二 进 制 数 比 较 为 了 实 现 上 面 的 操 作,C++ 提 供 了 类 型 转 换 操 作 符 () 其 看 起 来 和 括 号 操 作 符 一 样, 但 是 格 式 不 同 :(< 类 型 名 >)< 数 字 > 或 < 类 型 名 >(< 数 字 >) 上 面 类 型 转 换 操 作 符 的 < 类 型 名 > 不 是 数 字, 因 此 其 将 不 会 被 操 作, 而 是 作 为 一 个 参 数 来 控 制 其 如 何 操 作 后 面 的 < 数 字 > < 类 型 名 > 是 一 个 标 识 符, 其 唯 一 标 识 一 个 类 型, 如 char float 等 类 型 转 换 操 作 符 的 返 回 值 就 如 其 名 字 所 示, 将 < 数 字 > 按 照 < 类 型 名 > 标 识 的 类 型 来 解 释, 返 回 类 型 是 < 类 型 名 > 的 数 字 因 此, 上 面 的 例 子 我 们 就 需 要 如 下 编 写 :15 == ( char )15.0f;, 现 在 其 就 可 以 返 回 1, 表 示 逻 辑 真 了 但 是 即 使 不 写 ( char ) 句 也 返 回 1 这 是 编 译 器 出 于 方 便 的 缘 故 而 帮 我 们 在 15 前 添 加 了 ( float ), 所 以 依 然 返 回 1 这 被 称 作 隐 式 类 型 转 换, 在 后 面 说 明 类 的 时 候, 还 将 提 到 它 某 个 类 型 可 以 完 全 代 替 另 一 个 类 型 时, 编 译 器 就 会 进 行 上 面 的 隐 式 类 型 转 换, 自 动 添 加 类 型 转 换 操 作 符 如 :char 只 能 表 示 -128 到 127 的 整 数, 而 float 很 明 显 地 能 够 表 示 这 些 数 字, 因 此 编 译 器 进 行 了 隐 式 类 型 转 换 应 当 注 意, 这 个 隐 式 转 换 是 由 操 作 符 要 求 的, 即 前 面 的 == 要 求 两 面 的 数 字 类 型 一 致, 结 果 发 现 两 边 不 同, 结 果 编 译 器 将 char 转 成 float, 然 后 再 执 行 == 的 操 作 注 意 : 在 这 种 情 况 下, 编 译 器 总 是 将 较 差 的 类 型 ( 如 前 面 的 char) 转 成 较 好 的 类 型 ( 如 前 面 的 float), 以 保 证 不 会 发 生 数 值 截 断 问 题 如 :-41 == 3543;, 左 边 是 char, 右 边 是 short, 由 于 short 相 对 于 char 来 显 得 更 优 (short 能 完 全 char), 故 实 际 为 :( short )-41 == 3543;, 返 回 0 而 如 果 是 -41 == ( char 不 能 表 示 3543, 则 3543 以 补 码 转 成 二 进 制 数 0000110111010111, 然 后 取 其 低 8 位 高 8 位 的 00001101 被 丢 弃, 此 被 称 为 截 断 结 果 ( char )3543 的 返 回 值 就 是 类 型 为 char

制 数 11010111, 为 -41, 结 果 -41 == ( char )3543; 的 返 回 值 将 为 1, 表 示 逻 辑 误 因 此 前 面 的 15 == 15.0f; 实 际 将 为 ( float )15 == 15.0f;( 注 意 这 里 char 类 型 并 不 准 确, 更 多 的 编 译 器 是 将 它 解 释 成 int 类 型 ) 注 意 前 面 之 所 以 会 朝 好 的 方 向 发 展 ( 即 char 转 成 float), 完 全 是 因 为 == 的 缘 故, 其 要 求 这 么 做 下 面 考 虑 = :short b = 3543; char a = b; 因 为 b 的 值 是 而 = 的 要 求 就 是 一 定 要 将 = 右 边 的 数 字 转 成 和 左 边 一 样, 这 样 才 能 进 行 正 确 的 内 存 的 写 入 ( 简 单 地 将 右 边 数 字 返 回 的 二 进 制 数 复 制 到 左 边 的 地 址 所 表 示 的 内 存 中 ) 因 此 a 将 为 -41 但 是 上 面 是 编 译 器 按 照 = 的 要 求 自 行 进 行 了 隐 式 转 换, 可 能 是 由 于 程 序 员 的 疏 忽 而 没 有 发 现 这 个 错 误 ( 以 为 b 的 值 一 定 在 -128 到 127 的 范 围 内 ), 因 此 编 译 器 将 对 上 面 的 情 况 给 出 一 个 警 告, 说 b 的 值 可 能 被 截 断 为 了 消 除 编 译 器 的 疑 虑, 如 下 :char a = ( char )b; 这 样 称 为 显 示 类 型 转 换, 其 告 诉 编 译 器 我 知 道 可 能 发 生 数 据 截 断, 但 是 我 保 证 不 会 截 断 因 此 编 译 器 将 不 再 发 出 警 告 但 是 如 下 :char a = ( char )3543; 于 编 译 器 可 以 肯 定 3543 一 定 会 被 截 断 而 导 致 错 误 的 返 回 值, 因 此 编 译 器 将 给 出 警 告, 说 明 3543 将 被 截 断, 而 不 管 前 面 的 类 型 转 换 操 作 符 是 否 存 在 现 在 应 该 可 以 推 出 15 + 15.0f; 返 回 的 是 一 个 float 类 型 的 数 字 因 此 如 果 如 下 : a = 15 + 15.0f;, 编 译 器 将 发 出 警 告, 说 数 据 可 能 被 截 断 因 此 改 成 如 下 :char a = ( char )15 + 15.0f;, 但 类 型 转 换 操 作 符 () 的 优 先 级 比 + 高, 结 果 就 是 15 先 被 char 然 后 再 由 于 + 的 要 求 而 被 隐 式 转 成 float, 最 后 返 回 float 给 = 而 导 致 编 译 器 依 旧 发 出 警 告 为 此, 就 需 要 提 高 + 的 优 先 级, 如 下 :char a = ( char )( 15 + 15 事 了 ( 或 char( 15 + 15.0f )), 其 表 示 我 保 证 15 + 15.0f 不 会 导 致 数 据 截 断 应 该 注 意 类 型 转 换 操 作 符 () 和 前 缀 ++! 负 号 - 等 的 优 先 级 一 样, 并 且 是 从 右 向 左 计 算 的, 因 此 ( char )-34; 将 会 先 计 算 -34 的 值, 然 后 再 计 算 ( char ) 的 这 也 正 好 符 合 人 的 习 惯 下 篇 将 针 对 数 字 这 个 特 殊 操 作 符 而 提 出 一 系 列 的 东 西, 因 此 如 果 理 解 了 数 字 的 意 思, 那 么 指 针 将 很 容 易 理 解

C++ 从 零 开 始 ( 五 ) 何 谓 指 针 本 篇 说 明 C++ 中 的 重 中 又 重 的 关 键 指 针 类 型, 并 说 明 两 个 很 有 意 义 的 概 念 静 态 和 动 态 数 组 前 面 说 了 在 C++ 中 是 通 过 变 量 来 对 内 存 进 行 访 问 的, 但 根 据 前 面 的 说 明,C++ 中 只 能 通 过 变 量 来 操 作 内 存, 也 就 是 说 要 操 作 某 块 内 存, 就 必 须 先 将 这 块 内 存 的 首 地 址 和 一 个 变 量 名 绑 定 起 来, 这 是 很 糟 糕 的 比 如 有 100 块 内 存 用 以 记 录 100 个 工 人 的 工 资, 现 在 要 将 每 个 工 人 的 工 资 增 加 5%, 为 了 知 道 各 个 工 人 增 加 了 后 的 工 资 为 多 少, 就 定 义 一 个 变 量 float a1;, 用 其 记 录 第 1 个 工 人 的 工 资, 然 后 执 行 语 句 a1 += a1 * 0.05f;, 则 a1 里 就 是 增 加 后 资 由 于 是 100 个 工 人, 所 以 就 必 须 有 100 个 变 量, 分 别 记 录 100 个 工 资 因 此 上 面 的 赋 值 语 句 就 需 要 有 100 条, 每 条 仅 仅 变 量 名 不 一 样 上 面 需 要 手 工 重 复 书 写 变 量 定 义 语 句 float a1;100 遍 ( 每 次 变 一 个 变 量 名 ), 无 谓 的 工 作 因 此 想 到 一 次 向 操 作 系 统 申 请 100*4=400 个 字 节 的 连 续 内 存, 那 么 要 给 第 i 个 工 人 修 改 工 资, 只 需 从 首 地 址 开 始 加 上 4*i 个 字 节 就 行 了 ( 因 为 float 占 用 4 个 字 节 ) 为 了 提 供 这 个 功 能,C++ 提 出 了 一 种 类 型 数 组 数 组 即 一 组 数 字, 其 中 的 各 个 数 字 称 作 相 应 数 组 的 元 素, 各 元 素 的 大 小 一 定 相 等 ( 因 为 数 组 中 的 元 素 是 靠 固 定 的 偏 移 来 标 识 的 ), 即 数 组 表 示 一 组 相 同 类 型 的 数 字, 其 在 内 存 中 一 定 是 连 续 存 放 的 在 定 义 变 量 时, 要 表 示 某 个 变 量 是 数 组 类 型 时, 在 变 量 名 的 后 面 加 上 方 括 号, 在 方 括 号 中 指 明 欲 申 请 的 数 组 元 素 个 数, 以 分 号 结 束 因 此 上 面 的 记 录 100 个 工 资 的 变 量, 即 可 如 下 定 义 成 数 组 类 型 的 变 量 : float a[100]; 上 面 定 义 了 一 个 变 量 a, 分 配 了 100*4=400 个 字 节 的 连 续 内 存 ( 因 为 一 个 float 元 素 占 用 4 个 字 节 ), 然 后 将 其 首 地 址 和 变 量 名 a 相 绑 定 而 变 量 a 的 类 型 就 被 称 作 具 有 100 个 float 类 型 元 素 的 数 组 即 将 如 下 解 释 变 量 a 所 对 应 内 存 中 的 内 容 ( 类 型 就 是 如 何 解 释 内 存 的 内 容 ): a 所 对 应 的 地 址 标 识 的 内 存 是 一 块 连 续 内 存 的 首 地 址, 这 块 连 续 内 存 的 大 小 刚 好 能 容 纳 下 100 个 float 类 型 的 数 字 因 此 可 以 将 前 面 的 float b; 这 种 定 义 看 成 是 定 义 了 一 个 元 素 的 float 数 组 变 量 b 而 为 了 够 访 问 数 组 中 的 某 个 元 素, 在 变 量 名 后 接 方 括 号, 方 括 号 中 放 一 数 字, 数 字 必 须 是 非 浮 点 数, 即 使 用 二 进 制 原 码 或 补 码 进 行 表 示 的 数 字 如 a[ 5 + 3 ] += 32; 就 是 数 组 变 量 a 的 第 5 + 3 个 元 素 的 值 增 加 32 又 : long c = 23; float b = a[ ( c 3 ) / 5 ] 上 面 的 b 的 值 就 为 数 组 变 量 a 的 第 4 个 元 素 的 值 加 10, 而 d 的 值 就 为 数 组 变 量 a 的 第 0 个 元 素 的 值 即 C++ 的 数 组 中 的 元 素 是 以 0 为 基 本 序 号 来 记 数 的, 即 a[0] 实 际 代 表 的 是 数 组 变 量 a 中 的 第 一 个 元 素 的 值, 而 之 所 以 是 0, 表 示 a 所 对 应 的 地 址 加 上 0*4 后 得 到 的 地 址 就 为 第 一 个 元 素 的 地 址 应 该 注 意 不 能 这 样 写 :long a[0];, 定 义 0 个 元 素 的 数 组 是 无 意 义 的, 编 译 器 将 报 错, 不 过 在 结 构 或 类 或 联 合 中 符 合 某 些 规 则 后 可 以 这 样 写, 那 是 C 语 言 时 代 提 出 的 一 种 实 现 结 构 类 型 的 长 度 可 变 的 技 术, 在 C++ 从 零 开 始 ( 九 ) 中 将 说 明 还 应 注 意 上 面 在 定 义 数 组 时 不 能 在 方 括 号 内 写 变 量, 即 long b = 10; float a 误 的, 因 为 编 译 此 代 码 时, 无 法 知 道 变 量 b 的 值 为 多 少, 进 而 无 法 分 配 内 存 可 是 前 面 明 明 已 经 写 了 b = 10;, 为 什 么 还 说 不 知 道 b 的 值? 那 是 因 为 无 法 知 道 b 所 对 应 的 地 址 是 多 少 因 为 编 译 器 编 译 时 只 是 将 b 和 一 个 偏 移 进 行 了 绑 定, 并 不 是 真 正 的 地 址, 即 b 所 对 应 的 可 能 是 Base - 54, 而 其 中 的 Base 就 是 在 程 序 一 开 始 执 行 时 动 态 向 操 作 系 统 申 请 的 大 块 内 存 的 尾 地 址, 因 为 其 可 能 变 化, 故 无 法 得 知 b 实 际 对 应 的 地 址 ( 实 际 在 Windows 平 台 下, 由 于 虚 拟 地 址 空 间 的 运 用, 是 可 以 得 到 实 际 对 应 的 虚 拟 地 址, 但 依 旧 不 是 实 际 地 址, 故 无 法 编 译 时 期 知 道 某 变 量 的 值 ) 但 是 编 译 器 仍 然 可 以 根 据 前 面 的 long b = 10; 而 推 出 Base - 54 的 值 为 10 啊