继 承 -- 派 生 类
复 习 1. 有 下 面 类 的 说 明, 有 错 误 的 语 句 是 : class X { A) const int a; B) X(); C) X(int val) {a=2 D) ~X(); 答 案 :C 不 正 确, 应 改 成 X(int val) : a(2) {
2. 下 列 静 态 数 据 成 员 的 特 性 中, 错 误 的 是 A) 说 明 静 态 数 据 成 员 时 前 边 要 加 关 键 字 static 来 修 饰 B) 静 态 数 据 成 员 在 类 体 外 进 行 初 始 化 C) 使 用 静 态 数 据 成 员 时, 要 在 静 态 数 据 成 员 名 前 加 < 类 名 > 和 作 用 域 运 算 符 D) 静 态 数 据 成 员 不 是 所 有 对 象 所 共 有 的 答 案 :D 错 误, 应 该 是 共 有 的 C 正 确, 可 以 是 类 名 :: 静 态 成 员 或 对 象 名. 静 态 成 员
3. 下 面 程 序 段 输 出 结 果 是? class A { static int count; A() { count++; } void f(int x) {count+=x int int A::count=1; A a; A b; b.f(5); cout << a.count << endl; int A::count=1; //count=1 A a; // count=1+1=2 A b; //count=2+1=3 b.f(5); //count=3+5=8 cout << a.count << endl; ; // 输 出 8
继 承 的 概 念 软 件 复 用 : 新 的 软 件 可 以 在 原 先 开 发 的 基 础 上 进 行 扩 充, 可 以 降 低 成 本 提 高 软 件 可 靠 性 目 前, 不 加 修 改 地 直 接 复 用 已 有 软 件 比 较 困 难 已 有 软 件 的 功 能 与 新 软 件 所 需 要 的 功 能 总 是 有 差 别 的 解 决 这 个 差 别 有 下 面 的 途 径 : 修 改 已 有 软 件 的 源 代 码, 它 的 缺 点 是 : 需 读 懂 源 代 码 可 靠 性 差 易 出 错 源 代 码 难 以 获 得 继 承 机 制 (Inheritance): 一 种 面 向 对 象 的 软 件 复 用 途 径 在 定 义 一 个 新 的 类 时, 先 把 一 个 或 多 个 已 有 类 的 功 能 全 部 包 含 进 来, 然 后 再 给 出 新 功 能 的 定 义 或 对 已 有 类 的 某 些 功 能 重 新 定 义 C++ 的 继 承 通 过 派 生 类 来 实 现
为 什 么 使 用 继 承? 目 的 在 于 为 软 件 复 用 提 供 有 效 手 段 一 方 面, 可 以 重 用 先 前 项 目 的 代 码, 还 可 以 在 此 基 础 上 进 行 修 改, 提 高 程 序 设 计 灵 活 性 另 一 方 面, 如 果 一 个 项 目 使 用 了 几 个 功 能 相 似 的 类, 可 以 通 过 派 生 类 的 继 承 性 达 到 函 数 和 数 据 的 复 用, 减 少 重 复 设 计
基 类 与 派 生 类 在 继 承 关 系 中 存 在 两 个 类 : 基 类 ( 或 称 父 类 ) 和 派 生 类 ( 或 称 子 类 ) 派 生 类 拥 有 基 类 的 所 有 特 征, 并 可 以 定 义 新 的 特 征 或 对 基 类 的 一 些 特 征 进 行 重 定 义 基 类 派 生 类 继 承 分 为 : 单 继 承 和 多 继 承 单 继 承 : 一 个 类 最 多 有 一 个 直 接 基 类 多 继 承 : 一 个 类 可 以 有 多 个 直 接 基 类
继 承 对 程 序 设 计 的 支 持 继 承 机 制 除 了 支 持 软 件 复 用 外, 它 还 具 有 下 面 的 作 用 : 对 事 物 进 行 分 类 : 层 次 结 构,is-a-kind-of
支 持 软 件 的 增 量 开 发 : 新 的 版 本 可 以 从 老 的 版 本 扩 展 和 完 善 A1 A2 A3
对 概 念 进 行 组 合 : 例 如 在 职 研 究 生 既 是 教 师, 又 是 研 究 生, 综 合 了 两 种 特 征 研 究 生 教 师 在 职 研 究 生
单 继 承 在 定 义 单 继 承 时, 派 生 类 只 能 有 一 个 直 接 基 类, 其 定 义 格 式 如 下 : class < 派 生 类 名 >:[< 继 承 方 式 >] < 基 类 名 > { < 成 员 说 明 表 > < 派 生 类 名 > 为 派 生 类 的 名 字 < 基 类 名 > 为 直 接 基 类 的 名 字 < 成 员 说 明 表 > 是 在 派 生 类 中 新 定 义 的 成 员, 其 中 包 括 对 基 类 成 员 的 重 定 义 < 继 承 方 式 > 指 出 派 生 类 的 实 例 ( 对 象 ) 用 户 以 及 派 生 类 的 派 生 类 对 该 派 生 类 的 基 类 成 员 的 访 问 控 制
class A // 基 类 { int x,y; void f(); void g(); class B: public A // 派 生 类 { int z; // 新 成 员 void h(); // 新 成 员
关 于 派 生 类 的 说 明 1. 除 了 拥 有 新 定 义 的 成 员 外, 派 生 类 还 拥 有 基 类 的 所 有 成 员 ( 基 类 的 构 造 函 数 和 赋 值 操 作 符 重 载 函 数 除 外 ) 例 如 : B b; b b.x: b.y: b.z: b.f(); //A 类 中 的 f b.g(); //A 类 中 的 g b.h(); //B 类 中 的 h
2. 定 义 派 生 类 时 一 定 要 见 到 基 类 的 定 义 class A; // 声 明 class B: public A //Error { int z; void h() { g(); } //Error, 编 译 程 序 不 知 道 基 类 中 是 否 有 函 数 g 以 及 函 数 g 的 原 型... B b; //Error, 编 译 无 法 确 定 b 所 需 内 存 空 间 的 大 小
3. 友 元 不 具 有 继 承 性 : 如 果 在 派 生 类 中 没 有 显 式 说 明, 基 类 的 友 元 不 是 派 生 类 的 友 元 ; 如 果 基 类 是 另 一 个 类 的 友 元, 而 该 类 没 有 显 式 说 明, 则 派 生 类 也 不 是 该 类 的 友 元 4. 派 生 类 不 能 直 接 访 问 基 类 的 私 有 成 员 例 如 : class A { int x,y; void f(); void g() {... x... } class B: public A { int z; void h() {... x... //Error,x 为 基 类 的 私 有 成 员 g(); //OK, 通 过 函 数 g 访 问 基 类 的 私 有 成 员 x }
同 名 成 员 的 处 理 原 则 情 况 1: 派 生 类 可 以 定 义 新 的 成 员, 也 可 以 对 基 类 成 员 重 新 进 行 定 义 如 果 在 派 生 类 中 新 定 义 的 成 员 与 基 类 的 某 个 成 员 同 名, 则 在 派 生 类 中 对 该 成 员 的 访 问 是 指 派 生 类 中 定 义 的 成 员 例 如 : class A // 基 类 { int x,y; void f() {x=1; cout<< A.f, <<x; } ; void g() {y=2; cout<< A.g, <<y; class B: public A // 派 生 类 { int x,z; //x 被 重 定 义 int f() {x=3; cout<< B.f, <<x; //f 被 重 定 义 int h() { f(); // 使 用 B 类 的 f() g(); // 使 用 A 类 的 g() cout<< B.h, <<x<<; // 输 出 B 类 的 x B b; b.f(); // 使 用 B 类 中 的 f, 输 出 B.f, 3 b.g(); // 使 用 A 类 中 的 g, 输 出 A.g, 2 b.h(); // 使 用 B 类 中 的 h, 输 出 B.f, 3 A.g, 2 B.h, 3
同 名 成 员 的 处 理 原 则 情 况 2: 如 果 派 生 类 中 定 义 了 与 基 类 同 名 的 成 员, 则 基 类 的 成 员 名 在 派 生 类 的 作 用 域 内 不 直 接 可 见 访 问 基 类 同 名 成 员 时 要 用 基 类 名 受 限 例 如 : class B: public A { int z; void f(); void h() { f(); //B 类 中 的 f A::f(); //A 类 中 的 f } B b; b.f(); //B 类 中 的 f b.a::f(); //A 类 中 的 f
同 名 成 员 的 处 理 原 则 情 况 3: 即 使 派 生 类 中 定 义 了 与 基 类 同 名 但 参 数 不 同 的 成 员 函 数, 基 类 的 同 名 函 数 在 派 生 类 的 作 用 域 中 也 是 不 直 接 可 见 的 class B: public A { int z; void f(int); void h() { f(1); //OK f(); //Error A::f(); //OK }... B b; b.f(1); //OK b.f(); //Error b.a::f(); //OK
继 承 方 式 在 C++ 中, 派 生 类 拥 有 基 类 的 所 有 成 员 问 题 是 : 基 类 的 成 员 变 成 派 生 类 的 什 么 成 员 呢 (public private 或 protected)? 上 面 的 问 题 由 继 承 方 式 决 定 继 承 方 式 在 定 义 派 生 类 时 指 定 : class < 派 生 类 名 >:[< 继 承 方 式 >] < 基 类 名 > { < 成 员 说 明 表 > 继 承 方 式 可 以 是 :public private 和 protected 默 认 的 继 承 方 式 为 :private
继 承 方 式 的 含 义 继 承 方 式 派 生 类 基 类 public private protected public public 不 可 直 接 访 问 protected private private 不 可 直 接 访 问 private protected protected 不 可 直 接 访 问 protected 派 生 类 对 基 类 成 员 的 访 问 权 原 则 (1) 对 基 类 私 有 数 据 不 可 见 (2) 以 最 小 的 权 限 为 准
例 : 派 生 类 的 访 问 权 限 class A { void a(); protected: void b(); private: void c(); 1. 公 有 派 生 : class B: public A { void d(); // 在 B 类 里,a() 和 d() 是 public,b() 是 protected,c() 不 可 见 B x; x.a(); //OK 2. 保 护 派 生 : class B: protected A { void d(); // 在 B 类 里,d() 是 public, a(),b() 是 protected,c() 不 可 见 B x; x.a(); //error,a() 是 protected 3. 私 有 派 生 : class B: private A { void d(); // 在 B 类 里,d() 是 public, a(),b() 是 private,c() 不 可 见 B x; x.a(); //error,a() 是 private 不 管 以 何 种 派 生 方 式,B 类 都 可 以 访 问 A 类 的 a() 和 b(), 不 可 访 问 c()
继 承 方 式 的 调 整 在 派 生 类 中, 可 以 通 过 访 问 声 明 来 调 整 访 问 权 限 在 任 何 继 承 方 式 中, 除 了 基 类 的 private 成 员, 都 可 进 行 访 问 控 制 调 整 调 整 的 方 法 :[public : protected : private] 基 类 名 ::< 基 类 成 员 名 >, 例 如 class A { void f1(); void f2(); protected: void g1(); void g2() private: void p1(); } class B: private A { A::g1; A::p1; //Error,private 成 员 不 允 许 调 整 protected: A::f2; A::g2; private: A::f1; }
思 考 : 派 生 类 中 如 何 访 问 基 类 的 私 有 数 据? 方 法 1: 通 过 基 类 的 接 口 ( 公 有 函 数 ) 来 访 问 方 法 2: 把 基 类 的 private 数 据 改 成 protected 方 法 3: 将 派 生 类 或 其 成 员 函 数 声 明 为 基 类 的 友 元, 例 如 class B; class A { private: int x; friend class B; // 或 friend B::f(); } class B: public A { void f() { x=3 }
封 装 与 继 承 的 矛 盾 在 派 生 类 中 定 义 新 的 成 员 时, 往 往 需 要 用 到 基 类 的 一 些 private 成 员 ( 矛 盾 ) 在 继 承 机 制 中, 一 个 类 的 成 员 有 两 种 被 外 界 使 用 的 场 合 : 通 过 类 的 对 象 使 用 在 派 生 类 中 使 用 在 C++ 中, 提 供 了 另 外 一 种 类 成 员 访 问 控 制 : protected, 用 它 说 明 的 成 员 不 能 被 对 象 使 用, 但 可 以 在 派 生 类 中 使 用 protected 访 问 控 制 缓 解 了 封 装 与 继 承 的 矛 盾
class A { protected: int x,y; void f(); class B: public A {... void h() { f(); //OK... x... //OK... y... //OK } void f() { A a; a.f(); //OK... a.x... //Error... a.y... //Error }
派 生 类 对 象 的 初 始 化 派 生 类 对 象 的 初 始 化 由 基 类 和 派 生 类 共 同 完 成 : 基 类 的 数 据 成 员 由 基 类 的 构 造 函 数 初 始 化, 派 生 类 的 数 据 成 员 由 派 生 类 的 构 造 函 数 初 始 化 当 创 建 派 生 类 的 对 象 时, 派 生 类 的 构 造 函 数 在 进 入 其 函 数 体 之 前 会 去 调 用 基 类 的 构 造 函 数 默 认 情 况 下, 调 用 基 类 的 默 认 构 造 函 数, 如 果 要 调 用 基 类 的 非 默 认 构 造 函 数, 则 必 须 在 派 生 类 构 造 函 数 的 成 员 初 始 化 表 中 指 出 原 则 : 先 祖 先 ( 基 类 ), 再 客 人 ( 成 员 对 象 ), 后 自 己 ( 派 生 类 )
class A { int x; A() { x = 0; } A(int i) { x = i; } class B: public A { int y; B() { y = 0; } B(int i) { y = i; } B(int i, int j):a(i) { y = j; }... B b1; // 执 行 A::A() 和 B::B(),b1.x 等 于 0,b1.y 等 于 0 B b2(1); // 执 行 A::A() 和 B::B(int),b2.x 等 于 0,b2.y 等 于 1 B b3(1,2); // 执 行 A::A(int) 和 B::B(int,int),b3.x 等 于 1, //b3.y 等 于 2
如 果 一 个 类 D 既 有 基 类 B 又 有 成 员 对 象 类 M, 则 在 创 建 D 类 对 象 时, 构 造 函 数 的 执 行 次 序 为 : B->M->D 当 D 类 的 对 象 消 亡 时, 析 构 函 数 的 执 行 次 序 为 : D->M->B
例 : 利 用 一 个 线 性 表 类 实 现 一 个 队 列 类 线 性 表 由 若 干 元 素 构 成, 元 素 之 间 有 线 性 的 次 序 关 系 class LinearList {... bool insert( int x, int pos ); bool remove( int &x, int pos ); int element( int pos ) const; int search( int x ) const; int length( ) const;
队 列 是 一 种 特 殊 的 线 性 表, 插 入 操 作 在 一 端, 删 除 操 作 在 另 一 端 又 称 先 进 先 出 表 (First In First Out,FIFO) Queue 的 实 现 ( 继 承 ): class Queue: private LinearList { bool en_queue(int x) { return insert(x,length()); } bool de_queue(int &x) { return remove(x,1); }
小 结 继 承 的 概 念 为 什 么 使 用 继 承? 派 生 类 的 声 明 和 使 用 同 名 成 员 的 处 理 原 则 继 承 方 式 和 访 问 权 限 派 生 类 对 象 的 初 始 化 利 用 线 性 表 类 实 现 一 个 队 列 类
复 习 1. 下 面 关 于 友 元 的 描 述 中, 错 误 的 是 A) 友 元 函 数 可 以 访 问 该 类 的 私 有 数 据 成 员 B) 一 个 类 的 友 元 类 中 的 成 员 函 数 都 是 这 个 类 的 友 元 函 数 C) 友 元 可 以 提 高 程 序 的 运 行 效 率 D) 类 与 类 之 间 的 友 元 关 系 可 以 继 承 答 案 :D 错 误, 友 元 关 系 不 可 继 承, 不 对 称, 也 不 可 传 递
2. 下 列 对 派 生 类 的 描 述 中, 错 误 的 是 A) 一 个 派 生 类 可 以 作 另 一 个 派 生 类 的 基 类 B) 派 生 类 至 少 有 一 个 基 类 C) 派 生 类 的 成 员 除 了 它 自 己 的 成 员 外, 包 含 了 它 的 基 类 的 成 员 D) 派 生 类 中 继 承 的 基 类 成 员 的 访 问 权 限 到 派 生 类 保 持 不 变 答 案 :D
3. 下 面 程 序 段 输 出 结 果 是? class A // 基 类 { int x,y; int f() {x=1; return x} ; int g() {y=2; return y class B: public A // 派 生 类 { int x,z; int f() {y=3; return y; int h() { x=f()+g()+y; return x B b; cout<<b.h(); 解 答 : 根 据 同 名 处 理 的 原 则, 调 用 h() 函 数 时,f() 使 用 B 的 f, 返 回 3, g() 使 用 A 的 g, 返 回 2,y 等 于 2, 故 f()+g()+y=3+2+2=7
4. 下 列 A,B,C,D 处 函 数 调 用 正 确 的 是 : class A { void a(); protected: void b(); private: void c(); class B: private A { void d(); A::b; class C protected B { void f() { A) a(); B) b(); C) c(); D) d(); } } 解 答 : 类 B: d 和 b, private: a,c 不 可 见 类 C:protected d,b, 其 他 不 可 见 所 以 B,D 正 确,A,C 错 误
子 类 型 子 类 型 : 如 果 一 个 类 型 S 是 另 一 个 类 型 T 的 子 类 型, 则 对 用 T 表 达 的 所 有 程 序 P, 当 用 S 去 替 换 程 序 P 中 的 所 有 T 时, 程 序 P 的 功 能 不 变 一 个 类 型 的 操 作 也 适 合 于 它 的 子 类 型 以 及 一 个 子 类 型 的 值 可 以 赋 值 或 作 为 函 数 参 数 传 给 基 类 型 变 量 继 承 可 以 实 现 子 类 型 : 派 生 类 可 以 看 成 是 基 类 的 子 类 型 子 类 型 的 作 用 : 发 给 基 类 对 象 的 消 息 也 能 发 给 派 生 类 对 象 在 需 要 基 类 对 象 的 地 方 可 以 用 派 生 类 对 象 去 替 代
例 如, 假 设 A 是 基 类,B 是 A 的 派 生 类,f 是 A 的 成 员 函 数,g 是 B 的 成 员 函 数 A a,*p; B b,*q; b.f(); // 如 果 B 中 有 f, 则 调 用 B 的 f; 否 则 调 用 A 的 f a = b; // 用 b 去 改 变 a 的 状 态, 属 于 B 但 不 属 于 A 的 数 据 成 员 将 被 忽 略 p = &b; //A 类 指 针 p 指 向 B 类 对 象 b b = a; //Error, 它 将 导 致 b 有 不 确 定 的 成 员 数 据 (a 中 没 有 这 些 数 据 ) q = &a; //Error, 它 将 导 致 通 过 q 向 a 发 送 它 不 能 处 理 的 消 息, 如 :q->g();
多 继 承
多 继 承 对 于 下 面 的 两 个 类 A 和 B: class A { int m; void fa(); class B { int n; void fb(); 如 何 定 义 一 个 类 C, 它 包 含 A 和 B 的 所 有 成 员, 另 外 还 拥 有 新 的 数 据 成 员 r 和 成 员 函 数 fc?
用 单 继 承 实 现 : class C: public A { int n,r; void fb(); void fc(); 或 者 class C: public B { int m,r; void fa(); void fc(); 不 足 之 处 : 概 念 混 乱 易 造 成 不 一 致
用 多 继 承 实 现 : class C: public A, public B { int r; void fc();
多 继 承 是 指 派 生 类 可 以 有 一 个 以 上 的 直 接 基 类 多 继 承 的 派 生 类 定 义 格 式 为 : class < 派 生 类 名 >: [< 继 承 方 式 >] < 基 类 名 1>, { < 成 员 说 明 表 > [< 继 承 方 式 >] < 基 类 名 2>, 继 承 方 式 及 访 问 控 制 的 规 定 同 单 继 承 派 生 类 拥 有 所 有 基 类 的 所 有 成 员 基 类 的 声 明 次 序 决 定 : 对 基 类 构 造 函 数 / 析 构 函 数 的 调 用 次 序 对 基 类 数 据 成 员 的 存 储 安 排
多 继 承 的 初 始 化 多 继 承 的 构 造 函 数 的 调 用 顺 序 : (1) 先 祖 先 ( 基 类 ), 再 客 人 ( 成 员 对 象 ), 后 自 己 ( 派 生 类 ) (2) 多 个 基 类 的 初 始 化 顺 序 : 按 照 定 义 的 顺 序 来 区 分 先 后 析 构 函 数 和 构 造 函 数 相 反
class A { int m; void fa(); class B { int n; void fb(); class C: public A, public B { int r; void fc();... C c;
对 象 c 的 内 存 空 间 布 局 是 : c A::m B::n C::r 构 造 函 数 的 执 行 次 序 是 : A() B() C() 员 初 始 化 表 中 调 用 ) 下 面 的 操 作 是 合 法 的 : c.fa(); c.fb(); c.fc(); (A() 和 B() 实 际 是 在 C() 的 成
多 继 承 中 的 同 名 问 题 ( 二 义 性 ) class A {... void f(); void g(); class B {... void f(); void h(); class C: public A, public B {... void func() { f(); //Error, 是 A 的 f, 还 是 B 的 f? }... C c; c.f(); //Error, 是 A 的 f, 还 是 B 的 f?
解 决 名 冲 突 的 办 法 是 : 基 类 名 受 限 class C: public A, public B {... void func() { A::f(); //OK, 调 用 A 的 f B::f(); //OK, 调 用 B 的 f }... C c; c.a::f(); //OK, 调 用 A 的 f c.b::f(); //OK, 调 用 B 的 f
重 复 继 承 -- 虚 基 类 多 继 承 会 造 成 重 复 继 承 问 题 : 下 面 的 类 D 从 类 A 继 承 两 次, 称 为 重 复 继 承 class A { int x;... class B: public A {... class C: public A {... class D: public B, public C {... 重 复 继 承 会 带 来 二 义 性 : 上 面 的 类 D 将 包 含 两 个 x 成 员 : B::x 和 C::x 为 什 么 要 使 用 虚 基 类? 可 以 消 除 重 复 继 承 造 成 的 二 义 性
虚 基 类 的 概 念 和 定 义 虚 基 类 的 概 念 当 在 多 条 继 承 路 径 上 有 一 个 公 共 的 基 类, 这 个 公 共 的 基 类 就 会 产 生 多 个 实 例, 若 只 想 保 存 这 个 基 类 的 一 个 实 例, 可 以 将 这 个 公 共 基 类 声 明 为 虚 基 类 定 义 方 法 : 基 类 前 加 上 virtual 关 键 字 例 : 如 果 需 要 类 D 中 只 有 一 个 x, 则 应 把 A 定 义 为 B 和 C 的 虚 基 类 : class B: virtual public A {... class C: virtual public A {... class D: public B, public C {...
虚 基 类 的 初 始 化 虚 基 类 的 初 始 化 和 一 般 多 继 承 的 初 始 化 语 法 一 样, 但 构 造 函 数 调 用 次 序 不 同 构 造 函 数 的 调 用 次 序 虚 基 类 的 构 造 函 数 优 先 于 非 虚 基 类 构 造 函 数 调 用 若 同 一 层 次 包 含 多 个 虚 基 类, 则 按 照 他 们 的 声 明 先 后 顺 序 调 用 若 虚 基 类 由 非 虚 基 类 派 生 而 来, 则 仍 然 先 调 用 基 类 构 造 函 数, 再 调 用 派 生 类 构 造 函 数
例 : 虚 基 类 的 初 始 化 class A { int x; A(int i) { x = i; } class B: virtual public A { int y; B(int i): A(1) { y = i; } class C: virtual public A { int z; C(int i): A(2) { z = i; }
class D: public B, public C { int m; D(int i, int j, int k): B(i), C(j), A(3) { m = k; } class E: public D { int n; E(int i, int j, int k, int l): D(i,j,k), A(4) { n = l; }... D d(1,2,3); // 这 里,A 的 构 造 函 数 由 D 调 用,d.x 初 始 化 为 3 调 用 的 构 造 函 数 及 它 们 的 执 行 次 序 是 : A(3) B(1) C(2) D(1,2,3) E e(1,2,3,4); // 这 里, A 的 构 造 函 数 由 D 调 用,e.x 初 始 化 为 4 调 用 的 构 造 函 数 及 它 们 的 执 行 次 序 是 : A(4) B(1) C(2) D(1,2,3) E(1,2,3,4)
类 作 为 模 块 在 面 向 对 象 程 序 中, 可 以 把 一 个 类 当 作 一 个 模 块, 也 可 以 把 多 个 具 有 继 承 关 系 的 类 作 为 一 个 模 块 一 个 C++ 模 块 一 般 由 两 个 源 文 件 构 成, 一 个 是.h 文 件, 另 一 个 是.cpp 文 件 对 于 一 个 由 类 构 成 的 C++ 模 块, 它 的.h 文 件 中 存 放 的 是 类 的 定 义,.cpp 文 件 中 存 放 的 是 类 成 员 函 数 的 定 义 ( 实 现 )
//modele2.h class A { int I,j; void h(); void f(); void h(); } //module2.cpp #include module2.h ; void A::f() { i h() } void A::g() { } void A::h() { } //modele1.cpp int main() { A a; a.f(); a.g(); }
Demeter 法 则 良 好 的 程 序 设 计 风 格 过 程 式 结 构 化 程 序 设 计 对 象 式? 良 好 的 对 象 程 序 设 计 风 格 的 目 标 是 降 低 模 块 间 的 耦 合 度, 增 强 模 块 的 可 复 用 性 和 易 维 护 性 Demeter 法 则 : 一 个 类 的 成 员 函 数 除 了 能 访 问 自 身 类 结 构 的 直 接 子 结 构 ( 表 层 子 结 构 ) 外, 不 能 以 任 何 方 式 依 赖 于 任 何 其 他 类 的 结 构 ; 并 且 每 个 成 员 函 数 只 应 对 应 于 某 个 有 限 类 集 合 中 的 对 象 发 送 消 息 自 身 类 结 构 的 直 接 子 结 构 : 指 本 类 的 数 据 成 员 成 员 对 象 类 的 数 据 成 员 不 包 含 在 内
小 结 子 类 型 多 继 承 概 念 初 始 化 两 种 二 义 性 和 解 决 办 法 同 名 冲 突 问 题 : 类 名 受 限 重 复 继 承 问 题 : 虚 基 类 类 作 为 模 块 Demeter 法 则