1 复 习 ( 时 间 5 分 钟 ): 提 问 复 习 C++ 语 言 中 类 的 概 念 与 使 用 等 提 问 复 习 C++ 语 言 如 何 定 义 类 提 问 复 习 C++ 语 言 和 面 向 对 象 编 程 的 相 关 概 念 教 学 安 排 与 设 计 教 学 反 馈 与 反 思 (

课 程 名 称 C++ 程 序 设 计 授 课 班 级 教 师 姓 名 授 课 日 期 授 课 形 式 讲 授 ( ) 实 验 / 实 训 ( ) 习 题 ( ) 其 它 ( ) 授 课 章 节 或 项 目 名 称 ( 含 课 程 实 验 实 训 ) 基 类 与 派 生 类 任 务 目 标 合 理 地 使 用 封 装 掌 握 成 员 的 定 义 与 使 用 掌 握 成 员 权 限 的 使 用 教 学 重 点 成 员 权 限 的 用 法 教 学 难 点 将 客 观 事 物 转 化 为 类 有 效 地 定 义 内 部 成 员 课 外 作 业 编 写 一 个 C++ 程 序, 完 全 使 用 类 成 员 的 不 同 权 限, 体 会 其 不 同 用 法

1 复 习 ( 时 间 5 分 钟 ): 提 问 复 习 C++ 语 言 中 类 的 概 念 与 使 用 等 提 问 复 习 C++ 语 言 如 何 定 义 类 提 问 复 习 C++ 语 言 和 面 向 对 象 编 程 的 相 关 概 念 教 学 安 排 与 设 计 教 学 反 馈 与 反 思 ( 手 写 ) 2 讲 授 内 容 ( 时 间 35 分 钟 ) 基 类 与 派 生 类 : 通 过 继 承 机 制, 可 以 利 用 已 有 的 数 据 类 型 来 定 义 新 的 数 据 类 型 所 定 义 的 新 的 数 据 类 型 不 仅 拥 有 新 定 义 的 成 员, 而 且 还 同 时 拥 有 旧 的 成 员 我 们 称 已 存 在 的 用 来 派 生 新 类 的 类 为 基 类, 又 称 为 父 类 由 已 存 在 的 类 派 生 出 的 新 类 称 为 派 生 类, 又 称 为 子 类 在 C++ 语 言 中, 一 个 派 生 类 可 以 从 一 个 基 类 派 生, 也 可 以 从 多 个 基 类 派 生 从 一 个 基 类 派 生 的 继 承 称 为 单 继 承 ; 从 多 个 基 类 派 生 的 继 承 称 为 多 继 承 派 生 类 的 定 义 格 式 单 继 承 的 定 义 格 式 如 下 : class < 派 生 类 名 >:< 继 承 方 式 >< 基 类 名 > < 派 生 类 新 定 义 成 员 > 其 中,< 派 生 类 名 > 是 新 定 义 的 一 个 类 的 名 字, 它 是 从 < 基 类 名 > 中 派 生 的, 并 且 按 指 定 的 < 继 承 方 式 > 派 生 的 < 继 承 方 式 > 常 使 用 如 下 三 种 关 键 字 给 予 表 示 : public 表 示 公 有 基 类 ; private 表 示 私 有 基 类 ; protected 表 示 保 护 基 类 ; 多 继 承 的 定 义 格 式 如 下 : class < 派 生 类 名 >:< 继 承 方 式 1>< 基 类 名 1>,< 继 承 方 式 2>< 基 类 名 2>, < 派 生 类 新 定 义 成 员 > 可 见, 多 继 承 与 单 继 承 的 区 别 从 定 义 格 式 上 看, 主 要 是 多 继 承 的 基 类 多 于 一

个 派 生 类 的 三 种 继 承 方 式 承 方 式 公 有 继 承 (public) 私 有 继 承 (private) 保 护 继 承 (protected) 是 常 用 的 三 种 继 1. 公 有 继 承 (public) 公 有 继 承 的 特 点 是 基 类 的 公 有 成 员 和 保 护 成 员 作 为 派 生 类 的 成 员 时, 它 们 都 保 持 原 有 的 状 态, 而 基 类 的 私 有 成 员 仍 然 是 私 有 的 2. 私 有 继 承 (private) 私 有 继 承 的 特 点 是 基 类 的 公 有 成 员 和 保 护 成 员 都 作 为 派 生 类 的 私 有 成 员, 并 且 不 能 被 这 个 派 生 类 的 子 类 所 访 问 3. 保 护 继 承 (protected) 保 护 继 承 的 特 点 是 基 类 的 所 有 公 有 成 员 和 保 护 成 员 都 成 为 派 生 类 的 保 护 成 员, 并 且 只 能 被 它 的 派 生 类 成 员 函 数 或 友 元 访 问, 基 类 的 私 有 成 员 仍 然 是 私 有 的 下 面 列 出 三 种 不 同 的 继 承 方 式 的 基 类 特 性 和 派 生 类 特 性 不 同 继 承 方 式 的 基 类 和 派 生 类 特 性 继 承 方 式 基 类 特 性 派 生 类 特 性 公 有 继 承 public public protected private protected 不 可 访 问 私 有 继 承 public private protected private private 不 可 访 问 保 护 继 承 public protected protected private protected 不 可 访 问 为 了 进 一 步 理 解 三 种 不 同 的 继 承 方 式 在 其 成 员 的 可 见 性 方 面 的 区 别, 下 面 从 三 种 不 同 角 度 进 行 讨 论

对 于 公 有 继 承 方 式 : (1) 基 类 成 员 对 其 对 象 的 可 见 性 : 公 有 成 员 可 见, 其 他 不 可 见 这 里 保 护 成 员 同 于 私 有 成 员 (2) 基 类 成 员 对 派 生 类 的 可 见 性 : 公 有 成 员 和 保 护 成 员 可 见, 而 私 有 成 员 不 可 见 这 里 保 护 成 员 同 于 公 有 成 员 (3) 基 类 成 员 对 派 生 类 对 象 的 可 见 性 : 公 有 成 员 可 见, 其 他 成 员 不 可 见 所 以, 在 公 有 继 承 时, 派 生 类 的 对 象 可 以 访 问 基 类 中 的 公 有 成 员 ; 派 生 类 的 成 员 函 数 可 以 访 问 基 类 中 的 公 有 成 员 和 保 护 成 员 这 里, 一 定 要 区 分 清 楚 派 生 类 的 对 象 和 派 生 类 中 的 成 员 函 数 对 基 类 的 访 问 是 不 同 的 对 于 私 有 继 承 方 式 : (1) 基 类 成 员 对 其 对 象 的 可 见 性 : 公 有 成 员 可 见, 其 他 成 员 不 可 见 (2) 基 类 成 员 对 派 生 类 的 可 见 性 : 公 有 成 员 和 保 护 成 员 是 可 见 的, 而 私 有 成 员 是 不 可 见 的 (3) 基 类 成 员 对 派 生 类 对 象 的 可 见 性 : 所 有 成 员 都 是 不 可 见 的 承 所 以, 在 私 有 继 承 时, 基 类 的 成 员 只 能 由 直 接 派 生 类 访 问, 而 无 法 再 往 下 继 对 于 保 护 继 承 方 式 : 这 种 继 承 方 式 与 私 有 继 承 方 式 的 情 况 相 同 两 者 的 区 别 仅 在 于 对 派 生 类 的 成 员 而 言, 对 基 类 成 员 有 不 同 的 可 见 性 上 述 所 说 的 可 见 性 也 就 是 可 访 问 性 关 于 可 访 问 性 还 有 另 的 一 种 说 法 这 种

规 则 中, 称 派 生 类 的 对 象 对 基 类 访 问 为 水 平 访 问, 称 派 生 类 的 派 生 类 对 基 类 的 访 问 为 垂 直 访 问 一 般 规 则 如 下 : 公 有 继 承 时, 水 平 访 问 和 垂 直 访 问 对 基 类 中 的 公 有 成 员 不 受 限 制 ; 私 有 继 承 时, 水 平 访 问 和 垂 直 访 问 对 基 类 中 的 公 有 成 员 也 不 能 访 问 ; 保 护 继 承 时, 对 于 垂 直 访 问 同 于 公 有 继 承, 对 于 水 平 访 问 同 于 私 有 继 承 对 于 基 类 中 的 私 有 成 员, 只 能 被 基 类 中 的 成 员 函 数 和 友 元 函 数 所 访 问, 不 能 被 其 他 的 函 数 访 问 基 类 与 派 生 类 的 关 系 任 何 一 个 类 都 可 以 派 生 出 一 个 新 类, 派 生 类 也 可 以 再 派 生 出 新 类, 因 此, 基 类 和 派 生 类 是 相 对 而 言 的 基 类 与 派 生 类 之 间 的 关 系 可 以 有 如 下 几 种 描 述 : 1. 派 生 类 是 基 类 的 具 体 化 类 的 层 次 通 常 反 映 了 客 观 世 界 中 某 种 真 实 的 模 型 在 这 种 情 况 下, 不 难 看 出 : 基 类 是 对 若 干 个 派 生 类 的 抽 象, 而 派 生 类 是 基 类 的 具 体 化 基 类 抽 取 了 它 的 派 生 类 的 公 共 特 征, 而 派 生 类 通 过 增 加 行 为 将 抽 象 类 变 为 某 种 有 用 的 类 型 2. 派 生 类 是 基 类 定 义 的 延 续 先 定 义 一 个 抽 象 基 类, 该 基 类 中 有 些 操 作 并 未 实 现 然 后 定 义 非 抽 象 的 派 生 类, 实 现 抽 象 基 类 中 定 义 的 操 作 例 如, 虚 函 数 就 属 此 类 情 况 这 时, 派 生 类 是 抽 象 的 基 类 的 实 现, 即 可 看 成 是 基 类 定 义 的 延 续 这 也 是 派 生 类 的 一 种 常 用 方 法 3. 派 生 类 是 基 类 的 组 合 为 的 组 合 在 多 继 承 时, 一 个 派 生 类 有 多 于 一 个 的 基 类, 这 时 派 生 类 将 是 所 有 基 类 行 派 生 类 将 其 本 身 与 基 类 区 别 开 来 的 方 法 是 添 加 数 据 成 员 和 成 员 函 数 因 此, 继 承 的 机 制 将 使 得 在 创 建 新 类 时, 只 需 说 明 新 类 与 已 有 类 的 区 别, 从 而 大 量 原 有 的 程 序 代 码 都 可 以 复 用, 所 以 有 人 称 类 是 可 复 用 的 软 件 构 件

3 任 务 实 施 ( 时 间 30 分 钟 ) 通 过 C++ 语 言 的 类 来 反 映 客 观 事 物 : 1) 任 务 1, 描 述 学 生 这 一 客 观 事 物 的 属 性 与 特 点 ; 2) 任 务 2, 观 察 C++ 中 的 类 与 C 语 言 代 码 中 结 构 体 的 区 别 ; 3) 任 务 3, 掌 握 如 何 有 效 封 装 成 员 ; 4) 任 务 4, 独 立 编 写 一 个 包 含 类 成 员 权 限 的 C++ 程 序 class Man string name; string age; 利 用 继 承 机 制, 新 的 类 可 以 从 已 有 的 类 中 派 生 那 些 用 于 派 生 的 类 称 为 这 些 特 别 派 生 出 的 类 的 基 类 目 录 1 语 法 说 明 2 单 一 继 承 3 多 重 继 承 4 基 类 5 二 义 性 6 抽 象 类 实 例 1 分 析 1 实 例 2 分 析 2 7 概 念 描 述 二 义 性 全 局 名 称 名 称 及 限 定 名 函 数 参 量 名 称 1 语 法 说 明 编 辑 基 类 说 明 : 在 C++ 中 要 定 义 的 新 的 数 据 类 型 不 仅 拥 有 新 定 义 的 成 员, 而 且 还 同 时 拥 有 旧 的 成 员, 我 们 称 已 存 在 的 用 来 派 生 新 类 的 类 为 C++ 基 类, 又 称 为 父 类 基 类 表 : 基 类 表 中 存 放 各 个 基 类 名 称 基 类 说 明 符 : 基 类 类 体 中 类 成 员 的 访 问 说 明 符 2 单 一 继 承 编 辑 在 单 一 继 承 这 种 最 普 通 的 形 式 中, 派 生 类 仅 有 一 个 基 类 在 类 的 层 次 设 计 中, 可 以 发 现 一 些 普 遍 的 特 性, 即 派 生 类 总 是 同 基 类 有 kind

of 关 系 另 一 个 值 得 注 意 点 是 Book 既 是 派 生 类 ( 从 PrintedDocument 中 派 生 ), 也 是 基 类 (PaperbackBook 是 从 Book 派 生 的 ) 下 面 的 例 子 是 这 种 类 层 次 的 一 个 轮 廓 性 的 说 明 class PrintedDocument // 成 员 表 //Book 是 从 PrintedDocument 中 派 生 的 class Book:public PrintedDocument // 成 员 表 //PaperbackBook 是 从 Book 中 派 生 class PaperbackBook: public Book // 成 员 表 PrintedDocument 作 为 Book 的 直 接 基 类, 它 同 时 也 是 PaperbackBook 的 非 直 接 基 类 直 接 基 类 和 非 直 接 基 类 的 区 别 在 于 直 接 基 类 出 现 在 类 说 明 的 基 类 表 中, 而 非 直 接 基 类 不 出 现 在 基 类 表 中 每 个 派 生 类 的 说 明 是 在 基 类 的 说 明 之 后 说 明 的, 因 此 对 于 基 类 仅 只 给 出 一 个 前 向 引 用 的 说 明 是 不 够 的, 必 须 是 完 全 的 说 明 一 个 类 可 以 作 为 很 多 特 别 类 的 基 类 在 继 承 中, 派 生 类 含 有 基 类 的 成 员 加 上 任 何 你 新 增 的 成 员 结 果 派 生 类 可 以 引 用 基 类 的 成 员 ( 除 非 这 些 成 员 在 派 生 类 中 重 定 义 了 ) 当 在 派 生 类 中 重 定 义 直 接 基 类 或 间 接 基 类 的 成 员 时, 可 以 使 用 范 围 分 辨 符 (::) 引 用 这 些 成 员 考 虑 下 面 的 代 码 : class Document char * Name;// 文 档 名 称 void PrintNameOf(); // 打 印 名 称 // 实 现 类 Document 的 PrintNameOf 函 数 void Document::PrintNameOf() cout << Name << endl ; class Book:public Document

Book(char *name,long pagecount); private: long PageCount; //class Book 构 造 函 数 Book::Book (char *name,long pagecount) Name=new char [strlen(name)+1]; strcpy (Name,name); PageCount=pagecount; 注 意,Book 的 构 造 函 数 (Book::Book) 具 有 对 数 据 成 员 Name 的 访 问 权 在 程 序 中 可 以 按 如 下 方 式 创 建 Book 类 对 象 并 使 用 之 // 创 建 一 个 Book 类 的 新 对 象, 这 将 激 活 构 造 函 数 Book:BookBook Book LibraryBook ("Programming Windows,2nd Ed",994);... // 使 用 从 Document 中 继 承 的 函 数 PrintNameOf. LibraryBook.PrintNameOf(); 如 前 面 例 子 所 示, 类 成 员 和 继 承 的 数 据 与 函 数 以 一 致 的 方 式 引 用 如 果 类 Book 所 调 用 的 PrintNameOf 是 由 类 Book 重 新 定 义 实 现 的, 则 原 来 属 于 类 Document 的 PrintNameOf 函 数 只 能 用 范 围 分 辩 符 (::) 才 能 使 用 : class Book:public Document Book(char *name,long pagecount); void PrintNameOf(); long PageCount; void Book::PrintNameOf() cout<<"name of Book:"; Document::PrintNameOf(); 只 要 有 一 个 可 访 问 的 无 二 义 性 的 基 类, 派 生 类 的 指 针 和 引 用 可 以 隐 含 地 转 换 为 它 们 基 类 的 指 针 和 引 用 下 面 的 例 子 证 实 了 这 种 使 用 指 针 的 概 念 ( 同 样 也 适 用 于 引 用 ): #include <iostream.h> void main() Document * DocLib[10]; //10 个 文 档 的 库 for (int i=0; i<10; ++i) cout<<"type of document:"

<<"P)aperback,M)agazine,H)elp File,C)BT" << endl; char CDocType; cin >>CDocType; switch(tolower(cdoctype)) case 'p': DocLib=new PaperbackBook; break; case 'm': DocLib=new Magazine; break; case 'h': DocLib=new HelpFile; break; case 'c': DocLib=new ComputerBasedTraining; break; default: --i; break; for (i=0; i<10; ++i) DocLib->PrintNameOf(); 在 前 面 例 子 的 SWITCH 语 句 中, 创 建 了 不 同 类 型 的 对 象 这 一 点 依 赖 于 用 户 对 CDocType 对 象 所 作 出 的 说 明 然 而 这 些 类 型 都 是 从 类 Document 中 派 生 出 来 的, 故 可 以 隐 含 地 转 换 为 Document* 结 果 是 DocLib 成 为 一 个 相 似 链 表 (heterogeneous list) 此 链 表 所 包 含 的 是 不 同 种 类 的 对 象, 其 中 的 所 有 对 象 并 不 是 有 相 同 的 类 型 因 为 Document 类 有 一 个 PrintNameOf 函 数 因 此 它 能 够 打 印 图 书 馆 中 每 本 书 的 名 称, 但 对 于 Document 类 型 来 说 有 一 些 信 息 会 省 略 掉 了 ( 如 :Book 的 总 页 数, HelpFile 的 字 节 数 等 ) 注 意 : 强 制 基 类 去 实 现 一 个 如 PrintNameOf 的 函 数, 通 常 不 是 一 个 很 好 的 设 计, 本 章 后 面 的 虚 拟 函 数 中 提 供 了 一 个 可 替 换 的 设 计 方 法 3 多 重 继 承 编 辑 C++ 的 后 期 的 一 些 版 本 为 继 承 引 入 了 多 重 继 承 模 式 在 一 个 多 重 继 承 的 图 中, 派 生 类 可 以 有 多 个 直 接 基 类 对 于 一 个 特 定 的 程 序 如 果 每 个 类 的 属 性 并 不 是 全 部 要 求 使 用, 则 每 个 类 可 以

单 独 使 用 或 者 同 别 的 类 联 合 在 一 起 使 用 虚 基 类 层 次 有 一 些 类 层 次 很 庞 大, 但 有 很 多 东 西 很 普 遍 这 些 普 遍 的 代 码 在 基 类 中 实 现 了, 然 而 在 派 生 类 中 又 实 现 了 特 殊 的 代 码 对 于 基 类 来 说 重 要 的 是 建 立 一 种 机 制, 通 过 这 种 机 制 派 生 类 能 够 完 成 大 量 的 函 数 机 能 这 种 机 制 通 常 是 用 虚 函 数 来 实 现 的 有 时, 基 类 为 这 些 函 数 提 供 了 一 个 缺 省 的 实 现 了 解 到 所 有 的 Identify 和 WhereIs 的 函 数 实 现 返 回 的 是 同 种 类 型 的 信 息, 这 一 点 很 重 要 在 这 个 例 子 中, 恰 好 是 一 种 描 述 性 字 符 串 这 些 函 数 可 以 作 为 虚 拟 函 数 来 实 现, 然 后 用 指 向 基 类 的 指 针 来 调 用, 对 于 实 际 代 码 的 联 结 将 在 运 行 时 决 定, 以 选 择 正 确 的 Identify 和 WhereIs 函 数 类 协 议 的 实 现 类 可 以 实 现 为 要 强 制 使 用 某 些 协 议 这 些 类 称 为 抽 象 类, 因 为 不 能 为 这 种 类 类 型 创 建 对 象 它 们 仅 仅 是 为 了 派 生 别 的 类 而 存 在 当 一 个 类 中 含 有 纯 虚 拟 函 数 或 当 他 们 继 承 了 某 些 纯 虚 拟 函 数 却 又 没 有 为 它 们 提 供 一 个 实 现 时, 该 类 称 为 抽 象 类 纯 虚 拟 函 数 是 用 纯 说 明 符 定 义 的 虚 拟 函 数 如 下 : virtual char *Identify()=0; 基 类 Document 把 如 下 一 些 协 议 强 加 给 派 生 类 * 为 Identify 函 数 提 供 一 个 合 适 的 实 现 * 为 WhereIs 函 数 提 供 一 个 合 适 的 实 现 在 设 计 Document 类 时, 通 过 说 明 这 种 协 议, 类 设 计 者 可 以 确 保 如 不 提 供 Identify 和 WhereIs 函 数 则 不 能 实 现 非 抽 象 类 因 而 Document 类 含 有 如 下 说 明 : class Document... // 对 派 生 类 的 要 求, 它 们 必 须 实 现 下 面 这 些 函 数 virtual char *Identify()=0; virtual char *WhereIs()=0;... 4 基 类 编 辑 如 前 面 讨 论 的, 继 承 过 程 创 建 的 新 的 派 生 类 是 由 基 类 的 成 员 加 上 由 派 生 类 新 加 的 成 员 组 成 在 多 重 继 承 中, 可 以 构 造 层 次 图, 其 中 同 一 基 类 可 以 是 多 个 派 生 类 的 一 部 分 图 9.4 显 示 了 这 种 图 多 重 基 类 如 同 多 重 继 承 中 所 描 述 的, 一 个 类 可 以 从 多 个 基 类 中 派 生 出 来 在 派 生 类 由 多 个 基 类 派 生 出 来 的 多 重 继 承 模 式 中, 基 类 是 用 基 类 表 语 法 成 份 来 说 明 的 class CollectionOfBook:public Book,public Collection

// 新 成 员 基 类 的 说 明 顺 序 一 般 没 有 重 要 的 意 义, 除 非 在 某 些 情 况 下 要 调 用 构 造 函 数 和 析 构 函 数 的 时 候 在 这 些 情 况 下, 基 类 的 说 明 顺 序 会 对 下 面 所 列 的 有 影 响 由 构 造 函 数 引 起 的 初 始 化 发 生 的 顺 序 如 果 你 的 代 码 依 赖 于 CollectionOfBook 的 Book 部 分 要 在 Collection 部 分 之 前 初 始 化, 则 此 说 明 顺 序 将 很 重 要 初 始 化 是 按 基 类 表 中 的 说 明 顺 序 进 行 初 始 化 的 激 活 析 构 函 数 以 作 清 除 工 作 的 顺 序 同 样, 当 类 的 其 它 部 分 正 在 被 清 除 时, 如 果 某 些 特 别 部 分 要 保 留, 则 该 顺 序 也 很 重 要 析 构 函 数 的 调 用 是 按 基 类 表 说 明 顺 序 的 反 向 进 行 调 用 的 注 意 : 基 类 的 说 明 顺 序 会 影 响 类 的 存 储 器 分 布 不 要 对 基 类 成 员 在 存 储 器 中 的 顺 序 作 出 任 何 编 程 的 决 定 在 你 说 明 基 类 表 时, 不 能 把 同 一 类 名 称 说 明 多 次 但 是 对 于 一 个 派 生 类 而 言, 其 非 直 接 基 类 可 以 有 多 个 相 同 的 虚 拟 基 类 因 为 一 个 类 可 以 多 次 作 为 一 个 派 生 类 的 非 直 接 基 类 C++ 提 供 了 一 个 办 法 去 优 化 这 种 基 类 的 工 作 注 意, 在 LunchCashierQueue 对 象 中, 有 两 个 Queue 子 对 象 下 面 的 代 码 说 明 Queue 为 虚 拟 基 类 : class Queue // 成 员 表 class CashierQueue:virtual public Queue // 成 员 表 class LunchQueue: virtual public Queue // 成 员 表 class LunchCashierQueue:public LunchQueue,public CashierQueue // 成 员 表 一 个 类 对 于 给 定 的 类 型 既 可 以 有 虚 拟 的 组 成 部 分, 也 可 以 有 非 虚 拟 的 组 成 部 分 如 果 一 个 派 生 类 重 载 了 一 个 从 虚 拟 基 类 中 继 承 的 虚 拟 函 数, 而 且 该 派 生 类 以 指 向 虚 拟 基 类 的 指 针 调 用 这 些 构 造 函 数 和 析 构 函 数 时, 编 译 器 会 引 入 一 个 附 加 的 隐 含 的 vtordisp 域 到 带 有 虚 拟 基 类 的 类 中 /vd0 编 译 器 选 项 禁 止 了 这 个 增 加 的 隐 含 vtordisp 构 造 / 析 构 位 置 成 员 /vd1 选 项 ( 缺 省 ), 使 得 在 需 要 时 可 以 解 除 禁

止 只 有 在 你 确 信 所 有 类 的 构 造 函 数 或 析 构 函 数 都 虚 拟 地 调 用 了 虚 拟 函 数, vtordisp 才 可 以 关 掉 /vd 编 译 器 选 项 会 影 响 全 局 编 译 模 式 使 用 vtordisp 编 译 指 示 可 以 在 基 于 类 方 式 上 打 开 或 禁 止 vtordisp 域 : #pragma vtordisp(off) class GetReal:virtual public... #pragma vtordisp(on) 5 二 义 性 编 辑 实 例 多 重 继 承 使 得 从 不 同 的 路 径 继 承 成 员 名 称 成 为 可 能 沿 着 这 些 路 径 的 成 员 名 称 并 不 必 然 是 唯 一 的 这 些 名 称 的 冲 突 称 为 二 义 性 任 何 引 用 类 成 员 的 表 达 式 必 须 使 用 一 个 无 二 义 性 的 引 用 下 面 的 例 子 显 示 了 二 义 性 是 如 何 发 生 的 // 说 明 两 个 基 类 A 和 B class A unsigned a; unsigned b(); class B unsigned a(); // 注 意 类 A 也 有 一 个 成 员 "a" 和 一 个 成 员 "b" int b(); char c; // 定 义 从 类 A 和 类 B 中 派 生 出 的 类 C class C : public A,public B 分 析 按 上 面 所 给 出 的 类 说 明, 如 下 的 代 码 就 会 引 出 二 义 性, 因 为 不 清 楚 是 引 用 类 A 的 b 呢, 还 是 引 用 类 B 的 b: C *pc=new C; pc->b(); 考 虑 一 下 上 面 的 代 码, 因 为 名 称 a 既 是 类 A 又 是 类 B 的 成 员, 因 而 编 译 器 并 不 能 区 分 到 底 调 用 哪 一 个 a 所 指 明 的 函 数 访 问 一 个 成 员, 如 果 它 能 代 表 多 个 函 数 对 象 类 型 或 枚 举 则 会 引 起 二 义 性 编 译 器 通 过 下 面 的 顺 序 执 行 以 检 测 出 二 义 性 : ⒈ 如 果 访 问 的 名 称 是 有 二 义 性 的 ( 如 前 述 ), 则 产 生 一 条 错 误 信 息

⒉ 如 果 重 载 函 数 是 无 二 义 性 的, 它 们 就 没 有 什 么 问 题 了 ⒊ 如 果 访 问 的 名 称 破 坏 了 成 员 访 问 许 可, 则 产 生 一 条 错 误 信 息 在 一 个 表 达 式 产 生 了 一 个 通 过 继 承 产 生 的 二 义 性 时, 通 过 用 类 名 称 限 制 发 生 问 题 的 名 称 即 可 人 工 解 决 二 义 性, 要 使 前 面 的 代 码 以 无 二 义 性 地 正 确 编 译, 要 按 如 下 使 用 代 码 : C *pc = new C; pc->b::a(); 注 意 : 在 类 C 说 明 之 后, 在 C 的 范 围 中 引 用 B 就 会 潜 在 地 引 起 错 误 但 是, 直 到 在 C 的 范 围 中 实 际 使 用 了 一 个 对 B 的 无 限 定 性 的 引 用, 才 会 产 生 错 误 二 义 性 和 虚 拟 基 类 如 果 使 用 了 虚 拟 基 类 函 数 对 象 类 型 以 及 枚 举 可 以 通 过 多 重 继 承 的 路 径 到 达, 但 因 为 只 有 一 个 虚 拟 基 类 的 实 例, 因 而 访 问 这 些 名 称 时, 不 会 引 起 二 义 性 访 问 任 何 类 A 的 成 员, 通 过 非 虚 拟 基 类 访 问 则 会 引 起 二 义 性 ; 因 为 编 译 器 没 有 任 何 信 息 以 解 释 是 使 用 同 类 B 联 系 在 一 起 的 子 对 象, 还 是 使 用 同 类 C 联 系 在 一 起 的 子 对 象, 然 而 当 A 说 明 为 虚 拟 基 类 时, 则 对 于 访 问 哪 一 个 子 对 象 不 存 在 问 题 了 通 过 继 承 图 可 能 有 多 个 名 称 ( 函 数 的 对 象 的 枚 举 的 ) 可 以 达 到 这 种 情 况 视 为 非 虚 拟 基 类 引 起 的 二 义 性 但 虚 拟 基 类 也 可 以 引 起 二 义 性, 除 非 一 个 名 称 支 配 (dominate) 了 其 它 的 名 称 一 个 名 称 支 配 其 它 的 名 称 发 生 在 该 名 称 定 义 在 两 个 类 中, 其 中 一 个 是 由 另 一 个 派 生 的, 占 支 配 地 位 的 名 称 是 派 生 类 中 的 名 称, 在 此 名 称 被 使 用 的 时 候, 相 反 不 会 产 生 二 义 性, 如 下 面 的 代 码 所 示 : class A int a; class B: public virtual A int a(); class C: public virtual A... class D: public B,public C D() a(); // 不 会 产 生 二 义 性,B::a() 支 配 了 A::a 转 换 的 二 义 性 显 式 地 或 隐 含 地 对 指 向 类 类 型 的 指 针 或 引 用 的 转 换 也 可 引 起 二 义 性

实 例 1 虚 拟 函 数 可 以 确 保 在 一 个 对 象 中 调 用 正 确 的 函 数, 而 不 管 用 于 调 用 函 数 的 表 达 式 假 设 一 个 基 类 含 有 一 个 说 明 为 虚 拟 函 数 同 时 一 个 派 生 类 定 义 了 同 名 的 函 数 派 生 类 中 的 函 数 是 由 派 生 类 中 的 对 象 调 用 的, 甚 至 它 可 以 用 指 向 基 类 的 指 针 和 引 用 来 调 用 下 面 的 例 子 显 示 了 一 个 基 类 提 供 了 一 个 PrintBalance 函 数 的 实 现 : class Account Account(double d); // 构 造 函 数 virtual double GetBalance(); // 获 得 平 衡 virtual void PrintBalance(); // 缺 省 实 现 private: double _balance; // 构 造 函 数 Account 的 实 现 double Account::Account(double d) _balance=d; //Account 的 GetBalance 的 实 现 double Account::GetBalance() return _balance; //PrintBalance 的 缺 省 实 现 void Account::PrintBalance() cerr<<"error.balance not available for base type". <<endl; 两 个 派 生 类 CheckingAccount 和 SavingsAccount 按 如 下 方 式 创 建 : class CheckingAccount:public Account void PrintBalance(); //CheckingAccount 的 PrintBalance 的 实 0 现 void CheckingAccount::PrintBalance() cout<<"checking account balance:" << GetBalance();

class SavingsAccount:public Account void PrintBalance(); //SavingsAccount 中 的 PrintBalance 的 实 现 void SavingsAccout::PrintBalance() cout<<"savings account balance:" << GetBalance(); 函 数 PrintBalance 在 派 生 类 中 是 虚 拟 的, 因 为 在 基 类 Account 中 它 是 说 明 为 虚 拟 的, 要 调 用 如 PrintBalance 的 虚 拟 函 数, 可 以 使 用 如 下 的 代 码 : // 创 建 类 型 CheckingAccount 和 SavingsAccount 的 对 象 SavingsAccount *psavings=new SavingsAccount(1000.00); // 用 指 向 Account 的 指 针 调 用 PrintBalance Account *paccount=pchecking; paccount->printbalance(); // 使 用 指 向 Account 的 指 针 调 用 PrintBalance paccount=psavings; paccount->printbalance(); 分 析 1 在 前 面 的 代 码 中, 除 了 paccount 所 指 的 对 象 不 同, 调 用 PrintBalance 的 代 码 是 相 同 的 因 为 PrintBalance 是 虚 拟 的, 将 会 调 用 为 每 个 对 象 所 定 义 的 函 数 版 本, 在 派 生 类 CheckingAccount 和 SavingsAccount 中 的 函 数 覆 盖 了 基 类 中 的 同 名 函 数 如 果 一 个 类 的 说 明 中 没 有 提 供 一 个 对 PrintBalance 的 覆 盖 的 实 现, 则 将 采 用 基 类 Account 中 的 缺 省 实 现 实 例 2 派 生 类 中 的 函 数 重 载 基 类 中 的 虚 拟 函 数, 仅 在 它 们 的 类 型 完 全 相 同 时 才 如 此 派 生 类 中 的 函 数 不 能 仅 在 返 回 值 上 同 基 类 中 的 虚 拟 函 数 不 同 ; 参 量 表 也 必 须 不 同 当 指 针 或 引 用 调 用 函 数 时, 要 遵 循 如 下 规 则 : * 对 虚 拟 函 数 调 用 的 解 释 取 决 于 调 用 它 们 的 对 象 所 基 于 的 类 型 * 对 非 虚 函 数 调 用 的 解 释 取 决 于 调 用 它 们 的 指 针 或 引 用 的 类 型 下 面 例 子 显 示 了 在 使 用 指 针 调 用 虚 拟 或 非 虚 拟 函 数 时 它 们 的 行 为 :#include // 说 明 一 个 基 类 class Base virtual void NameOf(); // 虚 拟 函 数 void InvokingClass(); // 非 虚 拟 函 数

// 两 个 函 数 的 实 现 void Base::NameOf() cout<<"base::nameof\n"; void Base::InvokingClass() cout<<"invoked by Base\n"; // 说 明 一 个 派 生 类 class Derived:public Base void NameOf(); // 虚 拟 函 数 void InvokingClass(); // 非 虚 拟 函 数 // 两 个 函 数 的 实 现 void Derived::NameOf() cout<<"derived::nameof\n"; void Derived::InvokingClass() cout<<"invoked by Derived\n"; void main() // 说 明 一 个 Derived 类 型 的 对 象 Derived aderived; // 说 明 两 个 指 针, 一 个 是 Derived* 型 的, 另 一 个 是 Base* 型 的, 并 用 //aderived 初 始 化 它 们 Derived *pderived=&aderived; Base *pbase =&aderived; // 调 用 这 个 函 数 pbase->nameof(); // 调 用 虚 拟 函 数 pbase->invokingclass();// 调 用 非 虚 拟 函 数 pderived->nameof();// 调 用 虚 拟 函 数 pderived->invokingclass(); // 调 用 非 虚 拟 函 数 分 析 2 该 程 序 的 输 出 是 :

Derived::NameOf Invoked by Base Derived::NameOf Invoked by Derived 注 意, 不 管 调 用 NameOf 函 数 的 指 针 是 通 过 指 向 基 类 的 指 针 还 是 指 向 派 生 类 的 指 针, 它 调 用 的 函 数 是 派 生 类 的 因 为 NameOf 是 虚 拟 函 数, 而 且 pbase 和 pderived 指 向 的 对 象 都 是 派 生 类 的, 故 而 调 用 函 数 是 派 生 类 的 因 为 虚 拟 函 数 只 能 为 类 类 型 的 对 象 所 调 用, 所 以 你 不 能 把 一 个 全 局 的 或 静 态 函 数 说 明 为 虚 拟 的 在 派 生 类 中 说 明 一 个 重 载 函 数 时 可 以 用 virtual 关 键 字, 但 是 这 并 不 是 必 须 的, 因 为 重 载 一 个 虚 拟 函 数, 此 函 数 就 必 然 是 虚 拟 函 数 基 类 中 的 虚 拟 函 数 必 须 有 定 义, 除 非 它 们 被 说 明 为 纯 的 虚 拟 函 数 调 用 机 制 可 以 用 范 围 分 辨 符 (::) 明 确 地 限 定 函 数 名 称 的 方 法 来 加 以 限 制 考 虑 前 面 的 代 码, 用 下 面 的 代 码 调 用 基 类 的 PrintBalance pchecking->account::printbalance(); // 明 确 限 定 Account *paccount=pchecking; // 调 用 Account::PrintBalance paccount->account::printbalance();// 明 确 限 定 上 面 例 子 中 的 两 个 对 PrintBalance 的 调 用 都 限 制 了 虚 拟 函 数 的 调 用 机 制 6 抽 象 类 编 辑 抽 象 类 就 像 一 个 一 段 意 义 上 的 说 明, 通 过 它 可 以 派 生 出 特 有 的 类 你 不 能 为 抽 象 类 创 建 一 个 对 象, 但 你 可 以 用 抽 象 类 的 指 针 或 引 用 至 少 含 有 一 个 纯 虚 拟 函 数 的 类 就 是 抽 象 类 从 抽 象 类 中 派 生 出 的 类 必 须 为 纯 虚 拟 函 数 提 供 实 现, 否 则 它 们 也 是 抽 象 类 把 一 个 虚 拟 函 数 说 明 为 纯 的, 只 要 通 过 纯 说 明 符 语 法, 考 虑 一 下 本 章 早 些 时 候 在 虚 拟 函 数 中 提 供 的 例 子 类 Account 的 意 图 是 提 供 一 个 通 常 意 义 的 函 数 功 能,Account 类 型 的 对 象 太 简 单 而 没 有 太 多 用 处 因 此 Account 是 作 为 抽 象 类 的 一 个 很 好 的 候 选 : 实 例 1 class Account Account(double d); // 构 造 函 数 virtual double GetBalance();// 获 得 平 衡 virtual void PrintBalance()=0; // 纯 虚 拟 函 数 Private: double _balance; 分 析 1

这 里 的 说 明 同 前 一 次 的 说 明 的 唯 一 不 同 是 PrintBalance 是 用 纯 说 明 符 说 明 的 使 用 抽 象 类 的 限 制 抽 象 类 不 能 用 于 如 下 用 途 : * 变 量 或 成 员 数 据 * 参 量 类 型 * 函 数 的 返 回 类 型 * 明 确 的 转 换 类 型 另 外 一 个 限 制 是 如 果 一 个 抽 象 类 的 构 造 函 数 调 用 了 一 个 纯 虚 拟 函 数, 无 论 是 直 接 还 是 间 接 的, 结 果 都 是 不 确 定 的 但 抽 象 类 的 构 造 函 数 的 析 构 函 数 可 以 调 用 其 它 成 员 函 数 抽 象 类 的 纯 虚 拟 函 数 可 以 有 定 义, 但 它 们 不 能 用 下 面 语 法 直 接 调 用 : 抽 象 类 名 称 :: 函 数 名 称 () 实 例 2 在 设 计 基 类 中 含 有 纯 虚 拟 析 构 函 数 的 类 层 次 时, 这 一 点 很 有 用 因 为 在 销 毁 一 个 对 象 的 过 程 中 通 常 都 要 调 用 基 类 的 析 构 函 数, 考 虑 下 面 的 例 子 :#include // 说 明 一 个 带 有 纯 虚 拟 析 构 函 数 的 抽 象 类 class base base() virtual ~base()=0; // 提 供 一 个 析 构 函 数 的 定 义 base::~base() class derived:public base derived() ~derived() void main() derived *pderived=new derived; delete pderived; 分 析 2 当 一 个 由 pderived 所 指 的 对 象 销 毁 的 时 候, 会 调 用 类 derived 的 析 构 函 数, 进 而 调 用 基 类 base 中 的 析 构 函 数 纯 虚 拟 函 数 的 空 的 实 现 保 证 了 该 函 数 至 少 存 在 着 一 些 操 作 注 意 : 在 前 面 例 子 中, 纯 虚 拟 函 数 base::~base 是 在 derived::~

derived 中 隐 含 调 用 的 当 然 明 确 地 用 全 限 定 成 员 函 数 名 称 去 调 用 纯 虚 拟 函 数 是 可 能 的 ------------------------------------------------------------------------------- 7 概 念 描 述 编 辑 这 一 节 补 充 一 些 有 关 类 的 新 的 概 念 : * 二 义 性 * 全 局 名 称 * 名 称 和 限 定 名 * 函 数 的 参 量 名 称 * 构 造 函 数 初 始 化 器 二 义 性 名 称 的 使 用 在 其 范 围 中 必 须 是 无 二 义 性 的 ( 直 到 名 称 的 重 载 点 ) 如 果 这 个 名 称 表 示 了 一 个 函 数, 那 么 这 个 函 数 必 须 是 关 于 参 量 的 个 数 和 类 型 是 无 二 义 性 的 如 果 名 称 存 在 着 二 义 性, 则 要 运 用 成 员 访 问 规 则 全 局 名 称 一 个 对 象 函 数 或 枚 举 的 名 称 如 果 在 任 何 函 数 类 之 外 引 入 或 前 缀 有 全 局 单 目 范 围 操 作 符 (::), 并 同 时 没 有 同 任 何 下 述 的 双 目 操 作 符 连 用 * 范 围 分 辨 符 (::) * 对 象 和 引 用 的 成 员 选 择 符 (.) * 指 针 的 成 员 选 择 符 (->) 名 称 及 限 定 名 同 双 目 的 范 围 分 辨 符 (::) 一 起 使 用 的 名 称 叫 限 定 名 在 双 目 范 围 分 辨 符 之 后 说 明 的 名 称 必 须 是 在 该 说 明 符 左 边 所 说 明 的 类 的 成 员 或 其 基 类 的 成 员 在 成 员 选 择 符 (. 或 ->;) 后 说 明 的 名 称 必 须 是 在 该 说 明 符 左 边 所 说 明 的 类 类 型 对 象 的 成 员 或 其 基 类 的 成 员 在 成 员 选 择 符 的 右 边 所 说 明 的 名 称 可 以 是 任 何 类 类 型 对 象, 只 要 该 说 明 符 的 左 边 是 一 个 类 类 型 对 象, 而 且 该 对 象 的 类 定 义 了 一 个 重 载 的 成 员 选 择 符 (->;), 它 把 指 针 所 指 的 对 象 变 为 特 殊 的 类 类 型 编 译 器 按 下 面 的 顺 序 搜 索 一 个 名 称, 发 现 以 后 便 停 止 : ⒈ 如 果 名 称 是 在 函 数 中 使 用, 则 在 当 前 块 范 围 中 搜 索, 否 则 在 全 局 范 围 中 搜 索 ⒉ 向 外 到 每 一 个 封 闭 块 范 围 中 搜 索, 包 括 最 外 面 函 数 范 围 ( 这 将 包 括 函 数 的 参 量 ) ⒊ 如 果 名 称 在 一 个 成 员 函 数 中 使 用, 则 在 该 类 的 范 围 中 搜 索 该 名 称 ⒋ 在 该 类 的 基 类 中 搜 索 该 名 称 ⒌ 在 外 围 嵌 套 类 范 围 ( 如 果 有 ) 或 其 基 类 中 搜 索, 这 一 搜 索 一 直 到 最 外 层 包 裹 的 类 的 范 围 搜 索 之 后 ⒍ 在 全 局 范 围 中 搜 索

然 而 你 可 以 按 如 下 方 式 改 变 搜 索 顺 序 : ⒎ 如 果 名 称 的 前 面 有 ::, 则 强 制 搜 索 在 全 局 范 围 之 中 ⒏ 如 果 名 称 的 前 面 有 class struct 和 union 关 键 字, 将 强 制 编 译 器 仅 搜 索 class,struct 或 union 名 称 ⒐ 在 范 围 分 辨 符 的 左 边 的 名 称, 只 能 是 class,struct 和 union 的 名 称 如 果 在 一 个 静 态 成 员 函 数 中 引 用 了 一 个 非 静 态 的 成 员 名, 将 会 产 生 一 条 错 误 消 息 同 样 地, 任 何 引 用 包 围 类 中 的 非 静 态 组 员 会 产 生 一 条 错 误 消 息, 因 为 被 包 围 的 类 没 有 包 围 类 的 this 指 针 函 数 参 量 名 称 函 数 的 参 量 名 称 在 函 数 的 定 义 中 视 为 在 函 数 的 最 外 层 块 的 范 围 中 因 此, 它 们 是 局 部 名 称 并 且 在 函 数 结 束 之 后, 范 围 就 消 失 了 函 数 的 参 量 名 称 是 在 函 数 说 明 ( 原 型 ) 的 局 部 范 围 中, 并 且 在 说 明 结 束 以 后 的 范 围 中 消 失 缺 省 的 参 量 名 称 是 在 参 量 ( 它 们 是 缺 省 的 ) 范 围 中, 如 前 面 两 段 描 述 的, 然 而 它 们 不 能 访 问 局 部 变 量 和 非 静 态 类 成 员 缺 省 参 量 值 的 确 定 是 在 函 数 调 用 的 时 候, 但 它 们 的 给 定 是 在 函 数 说 明 的 原 始 范 围 中 因 此 成 员 函 数 的 缺 省 参 量 总 是 在 类 范 围 中 的 4 小 结 ( 时 间 5 分 钟 ) 1) 掌 握 C++ 语 言 的 封 装 特 性 ; 2) 掌 握 面 向 对 象 的 概 念 和 主 要 特 点 3) 掌 握 C++ 类 的 成 员 权 限 使 用 特 点 类 的 封 装 就 是 只 允 许 类 设 计 人 员 检 查 赋 予 数 据 成 员 的 任 何 数 值 的 有 效 性, 从 而 防 止 编 程 错 误 的 发 生 控 制 内 置 数 据 结 构 访 问 的 另 一 个 好 处 是, 类 的 作 者 可 以 随 便 改 变 这 些 数 据 结 构 的 设 计 而 不 会 影 响 使 用 该 类 的 程 序 的 其 他 部 分 5 训 练 作 业 ( 时 间 5 分 钟 ) 编 写 程 序, 利 用 C++ 代 码 描 绘 学 生 老 师 建 筑 物 等 客 观 事 物 ; 考 察 学 生 的 代 码 编 写 能 力 注 : 各 专 业 课 程 可 根 据 自 身 特 点, 修 改 教 学 活 动 模 块 定 义 与 时 间 安 排