您的位置：首页 > 编程语言 > C语言/C++

c++ primer plus 第11章 使用类

2017-02-27 10:09 274 查看
　　　一 般 来 说 ， 访 问 私 有 类 成员 的 唯 一 方 法 是 使 用 类 方 法 。 c + + 使 用 友 元 函 数 来 避 开 这 种 限制 。 要 让 函 数 成 为 友 元 ， 需 要 在 类 声 明 中 声 明 该 函 数 ， 并 在 声 明 前 加 上 关 键 字 friend 。


　　　c ＋＋扩展 了 对 运 算 符 的 重 载 ， 允 许 自 定 义 特 殊 的 运 算 符 函 数 ， 这 种 函 数 描 述 了 特 定 的 运 算 符 与 类 之间 的 关 系 。 运 算 符 函 数 可 以 是 类 成 员 函 数 ， 也 可 以 是 友 元 函 数 （ 有 一 些 运 算 符 函 数 只 能 是 类成 员 函 数 ） 。 要 调 用 运 算 符 函 数 ， 可 以 直 接 调 用 该 函 数 ， 也
可 以 以 通 常 的 句 法 使 用 被 重 载 的运 算 符 。 对 于 运 算 符 op ， 其 运 算 符 函 数 的 格 式 如 下 ：


　　　　　　operatorOXO(argument-list)

　　　argument-list表 示 该 运 算 符 的 操 作 数 。 如 果 运 算 符 函 数 是 类 成 员 函 数 ， 则 第 一 个 操 作 数 是 调 用 对 象， 它 不 在 argument-list 中 。 例 如 ， 本 章 通 过 为 vector 类 定 义 operator + （ ） 成 员 函 数 重载 了 加 法 。 如 果 ｕｐ，ｒｉｇｈｔ和 result 都 是 vector 对 象 ， 则
可 以 使 用 下 面 的 任 何 一 条 语 句 来 调 用 矢 量 加 法 ：

　　　　　　result= up.operator+ (right) ；

　　　　　　result= up + right;

　　　在 第 二 条 语 句 中 ， 由 于 操作 数 up 和 right 的 类 型 都 是 Vector ， 因 此 c + + 将 使 用 № ctor 的 加 法 定 义 。


　　　当 运 算 符 函 数 是 成 员 函 数时 ， 则 第 一 个 操 作 数 将 是 调 用 该 函 数 的 对 象 。 例 如 ， 在 前 面 的 语 句 中 ， 对 象 是 调 用 函 数 的 对象 。 定 义 运 算 符 函 数 时 ， 如 果 要 使 其 第 一 个 操 作 数 不 是 类 对 象 ， 则 必 须 使 用 友 元 函 数 。


这 样 就 可 以 将 操 作 数 按 所 需 的顺 序 传 递 给 函 数 了 。


　　　最 常 见 的 运 算 符 重 载 任 务之 一 是 定 义 < < 运 算 符 ， 使 之 可 与cout 一 起 使 用 ， 来 显 示 对 象 的 内 容 。 要 让 ｏｒｓｔｒｅａｍ对 象 成 为 第 一 个 操 作 数 ， 需 要 将运 算 符 函 数 定 义 为 友 元 ： 要 使 重 新 定 义 的 运 算 符 能 与 其 自 身 拼 接 ， 需 要 将 返 回 类 型 声 明 为 0 ｓｔｒｅａｍ　& 。 下
面 的 通 用 格 式 能 够 满足 这 种 要 求 ：

　　　　　　　ostream & operator« (ostream & OS, const 0name & Obj ）


　　　　　　　｛

　　　　　　　　　　　ｏｓ　＜＜  …;     //display object contents

                              Return 0s;

　　　　　　　　｝

然 而 ， 如 果类包 含 这 样 的 方 法 ， 它 返 回 需 要 显 示 的 数 据 成 员的 值 ， 则 可 以 使 用 这 些 方 法 ， 无 需 在 operator«( ） 中 直接 访 问 这些 成 员 。 在 这 种 情 况 下 ， 函 数 不 必 （ 也 不 应 当 ） 是 友 元 。


C++允 许 指 定 在 类 和 基 本 类 型 之 间进 行 转 换 的 方 式 。 首 先 ， 任 何 接 受 唯 一 一 个 参 数 的 构 造 函 数 都 可 被 用 作 转 换 函 数 ， 将 类 型 与该 参 数 相 同 的 值 转 换 为 类 。 如 果 将 类 型 与 该 参 数 相 同 的 值 赋 给 对 象 ， 则C++ 将 自 动 调 用 该 构 造 函 数 。 例 如 ， 假 设 有 一 个 string
类， 它 包 含 一 个 将 char *值 作 为 其 唯 一 参 数 的 构 造 函 数 ， 那 么 如 果 bean 是 String 对 象 ， 则 可 以 使 用 下 面 的 语句 ：


Bean = “pinto”;     / / converts type char * to type string


然 而 ， 如果 在 该 构 造 函 数 的 声 明 前 加 上 了 关 键 字 explicit ， 则 该 构 造 函 数将 只 能 用 于 显 式 转 换 ：
[/b]

bean = String("pinto") ;      / / converts type char * to typeString explicitly


要 将 类 对象 转 换 为 其 他 类 型 ， 必 须 定 义 转 换 函 数 ， 指 出 如 何 进 行 这 种 转 换 。 转 换 函 数 必 须 是 成 员 函 数。 将 类 对 象 转 换 为 typeName 类 型 的 转 换 函 数 的 原 型 如 下 ：


operator typeName ;

注 意 ， 转换 函 数 没 有 返 回 类 型 、 没 有 参 数 ， 但 必 须 返 回 转 换 后 的 值 （ 虽 然 没 有 声 明 返 回 类 型 ） 。 例 如， 下 面 是 将 Vector 转 换 为 double 类型 的 函 数 ：


Vec tor：： operator double （ ）

{

return a double value;

}

经 验 表 明，最 好 不 要 依 赖 于 这 种 隐 式 转 换 函 数 。


您 可 能 己经 注 意 到 了 ， 与 简 单 的 c · 风 格 结 构 相 比 ， 使 用 类 时 ， 必 须 更 谨慎 、 更 小 心 ， 但 作 为 补 偿 ， 它 们 为 我 们 完 成 的 工 作 也 更 多 。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航