C++ Primer读书笔记2(经典收藏)

标题： 重 载 函数再 论

重 载 函数是 C++ 提出来的概念，但是在 C 中却未必没有。比如 “1+3” 和 “1.0+3.0” ， 虽 然都是加法，做的却不是同的操作： 编译 器要因操作数的不同而 调 用不同的加法操作。只是 C 语 言中除了内部 类 型 变 量可以参与运算以外，没有 “ 类 ” 这么 高深的概念。 “ 结 构体 ” 也只是内存数据的 组织 方法，而不 涉 及 对 整个 结 构体的 处 理。所以，在 C 语 言 时 代 编译 器明明做了 类 似于重 载 的事情，却可以像雷 锋 一 样 “ 做好事不留名 ” 。
　　 C++ 发 展出了 类 ，并且 赋 予了 “ 类 ” 很高的期望， 类 的 对 象也能像内置 类 型 对 象一 样 参与一切运算。那 么 ，就拿加法运算来 说 ， 编译 器如何知道 对 某 类对 象的加法 该调 用哪一个 详细 的操作代 码 ？于是，即使不出 现 普通函数的重 载 ，至少运算符是要重 载 的。
　　林 锐 博士在《高 质 量 C++/C 编 程指南》中 为 重 载 函数的必要性提了另一个理由： 类 的构造函数名称必 须 与 类 名相同，而 类 却 经 常要定 义 多个不同的构造函数。那就只好重 载 了。
　　 对 于普通程序 员 来 说 ，我 们 完全可以不用考 虑 得 这么 深。重 载 函数 给 我 们 至少 还带 来了另一个好 处 ：不用 记忆 多个不同的函数名了，也不用 为 了 给 函数起名而 绞 尽 脑 汁了。不 过 本 书还给 出了一个建 议 ：并不是任何 时 候都有必要重 载 函数的，有的 时 候不同的函数名可 以直 观 地 带 来好多信息， 滥 用重 载 只是 牺 牲了名称中的信息。

 

标题： ：重 载 函数的概念

引用：出 现 在相同作用域中的两个（可以是两个以上 —— 偷 猫注）函数，如果具有 相同的名字而形参表不同， 则 称 为 重 载 函数。
　　本 节开头 第一句 话 就 给 出了重 载 函数的定 义 ：重 载 函数必 须 符合两个条件：一是出 现 在相同的作用域中、二是函数名字相同而形参表不同。
　　其中第一个条件一般人往往是不去想的，其 实 函数名相同而作用域不同的函数大大存在，比如在 MFC 中就有。它 们 是完全不相干的函数。
　　第二个条件 还 可以 详说 一下：函数名字相同当然不在 话 下， 这 是函数被称 为 “ 重 载 ” 的根源。之于形参表不同，可能表 现 在形参个数不同、可能表 现 在形参 类 型不同、 还 可能表 现 在形参 顺 序不同。
　　如果要 扩 展 开 来 说 ， 还 可以 举 出 许 多 不是重 载 函数的情况。
　　一、如果既在同一作用域下、名称也相同、形参表也相同， 则 后者被 视为 前者的重 复 声明。 —— 函数可以重 复 声明，因 为 函数的声明并不 产 生目 标 代 码 ，但是函数的定 义 不允 许 重 复 出 现 。
　　二、如果既在同一作用域下、名称也相同、形参表也相同，但是返回 值 不同， 则 后者被 视为错误 的声明。函数不可以只凭返回 值 来区分，因 为调 用函数的 时 候只凭名称和形参来 选择 函数，而不凭返回 值 。再究其原因，一是因 为 函数的返回 值 可以被 丢 弃；二来即使不 丢 弃，将返回 值赋 予另一个 变 量之前没必要 检查 我需要什 么样 的返回 值 ，而能否 赋值 也与函数本 身无 关 。
　　三、有些 时 候看起来形参表不同， 实际 上是完全相同的， 书 本第 229 页讲 了四 组这样 的例子：
Record lookup(const Account &acct);
Record lookup(const Account &);// 区 别 在于有没有 给 形参命名
typedef Phone Telno;
Record lookup(const Phone&);
Record lookup(const Telno&);// 只是 给类 型取了个 别 名
Record lookup(const Phone&, const Name&);
Record lookup(const Phone&, const Name& = "");// 区 别 在于 给 形参提供了默 认值
Record lookup(Phone);
Record lookup(const Phone);// 区 别 在于是否 const 　　
　　其中第三 组 可能会 让 人 产 生函数的形参个数不同的假像，其 实 可缺省的形参并没有减少形参的个数。第四 组 有点不容易搞清：因 为 有的 时 候可以凭是否 const 来重 载 ，比如引用 传递 和指 针传递 。

 

标题： ：文件的 组织

一个程序往往由多个源文件 组 成， 这 些代 码 究竟 应该 放在哪个源文件里、哪些代 码 可以放在同一个源文件里、哪些代 码 必需分 开 放。 这 是一个管理 层 面的 问题 。
　　 说 它是管理 层 面的 问题 ，是因 为这 些代 码 的 组织 往往没有惟一的准 则 。但是它 们还 是有一定的 规 律的。
　　首先， 软 件的 维护 是一个 复杂 的系 统 工程。代 码 的 组织应该 有利于 维护 。 应该 尽量把直接相 关 的内容放在同一文件、不相 关 的内容放在不同的文件里。如果 这 些代 码还 有 亲 和疏，那就要分不同的文件 夹 来存放了。
　　其次， 软 件的代 码 是一个 严 格的 组织 体系。不同的内容之 间 可能是并列的，也可能有必要的先后 关 系。于是在 “#include” 的 时 候要注意 顺 序。
　　最后，也是最重要的一点，有些代 码 在同一工程中可以重用（或必 须 重用），有些代 码 在同一个工程中只能出 现 一次。可以重用的有 类 的声明、函数的声明、 变 量的声明等，不可以重用的是 类 的 实 体、函数的 实 体、 变 量的定 义 等。那 么 ，把可以重用的内容放在 h 文件中，把不可以重用的放在 cpp 文件中是一个好 办 法。
　　拿 类 的声明和 类 的 实 体 为 例，如果把一个 类 的所有内容一古 脑 放在同一个文件中，将可能出 现问题 。因 为 在其它用到 类实 例的地方都必 须让类 的声明 “ 可 见 ” ，所以我 们 往往在文件 头 部加个 “#include” ， 结 果 类 的 实 体也被 编译 多次，在 连 接 时产 生冲突。
　　在前文中曾提到 过 ，内 联 函数是惟一允 许 （也是必 须 ）在 编译时让 函数 实 体可 见 的的函数。所以内 联 函数可以放在 h 文件中。 C++ 规则 中有一句正好与此照 应 ：在 类 的声明中直接写出的函数被 认为 是内 联 函数。
　　 Visual C++ 给类 的文件起默 认 名 时 ，文件名往往与 类 名一致。如果 类 名由 “C” 开头 ， 则 文件会是除去 开头 的 “C” 字以外的其它文字。如 类 “CMyClass” ，它的代 码 存放在以下两个文件中： “MyClass.h” 和 “MyClass.cpp” 中。原因是 VC++ 建 议类 名以 C 开头 ，至于 为 什 么 在文件名中不出 现开头 的 “C” ，可能是出于微 软 的 习惯 吧 。

 

标题： ： 类 的构造函数

引用：构造函数是特殊的成 员 函数。
　　笔 记 ：构造函数的确是一 类 “ 特殊 ” 的成 员 函数。它的特殊性至少表 现 在以下几个方面：一是它的 调 用不用程序 员 操心，只要 类对 象被 创 建它就会被 调 用，而且它不允 许 被程序 员显 式地 调 用。二是它 们 是必需的，如果程序 员偷懒 ， 编译 器将自 动创 建 简单 的构造函数。三是它 们 的名字不用程序 员 多考 虑 ，直接与 类 名相同。四是它 们 没有返回 值 。
　　下面 详说这 几个特性：
　　一、它 们 在 类对 象被 创 建 时 自 动调 用， 创 建 对 象可能有以下方法：程序中用声明 变 量的 语 句直接声明 创 建，或者在程序中用 new 关键 字 动态创 建。 这 两 种 方法都可以 创 建 单 个 对 象，也都可以 创 建 对 象数 组 。只要有一个 对 象被 创 建，构造函数就被 调 用一次。
　　如果程序 员 想 显 式地 调 用构造函数那是不行的。正因 为 如此，构造函数中 还 有一 种 特定的部分叫 “ 初始化列表 ” ，通 过 它程序 员 可以 调 用基 类 或成 员 的构造函数。必竟 类 的 设计 千差万 别 ，如果某个 类 的基 类 或（和）成 员 有多个构造函数，那 么 ， 该类 必 须 能 够 指定用哪一个构造函数，否 则类 的功能将大打折扣。 调 用构造函数不是程序 员 的事，程序 员 不 应该 管也管不了。初始化列表 为 解决 这 个 问题 而生，所以只有构造函数才有初始化列表，其它函数不能有。
　　上面 说 到的 “ 大打折扣 ” 究竟是怎 样 的折扣呢？如果 不能指定基 类 和成 员 用哪一个构造函数，那就只好 让编译 器去挑了，构造出来的 对 象往往不符合要求，只好 调 用基 类 和成 员 的其它函数，比如 赋值 函数或其它 进 行参数 设 定的函数 —— 当然，基 类 和成 员 必 须 包含 这样 的函数。 这样 就浪 费 了 资 源。
　　二、 类 必 须 包含构造函数 —— 确切地 说 是必 须 包含无参数构造函数和拷 贝 构造函数 —— 原因是因 为 它 们 的 调 用是自 动 的。如果 这 两个函数根本就没有，你 让 系 统 如何 调 用？所以， C++ 也不含糊，你要是 懒 得写，它就帮你写一个 简单 的。 简单 就意味着至少要 丧 失一些功能，如果 类设计 得比 较复杂 （比如包含指 针 操作） 还 可能引起灾 难 性事故。
　　三、函数名与 类 名一致。构造函数的名称是必 须 特殊的，即使 这 个特殊不表 现 在与 类 名相同，也必 须 找到另一个 规则 来 实现 。因 为 系 统 要自 动调 用 这 些函数，你就必 须让 系 统 知道哪些函数是构造函数。
　　第四个特性直接改 变 了 C/C++ 语 言的一条 规则 ： C 语 言 规 定，如果函数没有明 显 指出返回 类 型，那 么 C 语 言 认为 返回 值 是 int 型。 C 语 言之所以可以有 这 条 规则 ，一是因 为 返回 int 的函数很多，二是因 为 即使没有返回 值 ，也必 须 指明 void 。当 时 制定 规则 的人无法 预 料到， C++ 中居然会出 现 “ 连 void 都不是的返回 值 ” 的函数， void 虽 然表示不返回任何 值 ，必竟与 类 构造函数的 “ 没有返回 值 ” 是两 码 事。于是， C++ 新 标 准 规 定：在定 义 或声明函数 时 ，没有 显 式指定返回 类 型中不合法的。当然 类 的构造函数除外。
　　构造函数的出 现 有它的可行院 捅 厝恍浴？尚行允怯捎 贑 ++ 的 类 允 许 包含成 员 函数，既然 类 可以包含普通的成 员 函数，那 么 包含特殊的函数自然也不在 话 下。必然性是由于 类 的 对 象往往必 须经过 特定的初始化。 C++ 到来之前， C 语 言中的数据 类 型只是内置 类 型。 对 于内置 类 型 对 象，如果忘了初始化，大不了 这 个 对 象失去作用，但是不会 导 致大的 问题 。比如一个 int 型 值 ，无 论 内存如何随 机，它的取 值 范 围 都不会超 过 int 能表达的范 围 ， 对 它 进 行运算也不会 产 生危 险 （溢出不能算危 险 ，即使初始化 过 的数据也不能保 证 不溢出，而且溢出只是一 种逻辑问题 ）。但是 现 在的 类 不 这么简单 了，忘了初始化往往将 带 来运行 错误 。于其 每 次都要考 虑 数据的初始化， 还 不如把 这 个初始化写成 统 一的函数， 让 系 统 自 动调 用来得既安全又方便 。

 

 

标题： ： 类 的成 员 函数

类 与 C 语 言中的 结 构体最大的区 别 就是 类 可以 带 函数，而 结 构体只是一个内存 组 合 。所以，要提 类 就不得不提成 员 函数。
　　 类 的成 员 函数与普通函数（全局函数）相比，最根本的区 别 是 实现 了 类 的封装性。封装性的第一个表 现 是 访问权 限：都是函数，但是你能 访问 哪个不能 访问 哪个却可以 设 定。第二个表 现 是直 观 ，通 过类 成 员 （或指 针 ）来 调 用函数， 给 人的直 觉 就是 “ 这 是 类 提供的功能 ” 。你好像 “Bird.Fly();” 一 样 一目了然。
　　在理解 this 指 针 以前要想 彻 底理解成 员 函数是有困 难 的，我就曾以 为 在 类 的 实 例中保存了函数的副本。要不然， 为 什 么 同一个 类 的不同 对 象 调 用 这 个函数有不同的效果呢？原来，在函数所有的形参之外， 还 有一个不用你操心的参数 this ，它是一个指 针 ， 该 指 针 的目 标 就是函数的 调 用者。 这么 一 说 就明白了。
　　函数形参表后加入 const 就成了 “const 成 员 函数 ” ， 这样 的函数保 护 了 调 用者自身不被修改。如 CString 的 GetLength() 函数，你只能 获 取它的 长 度，不能修改它的内容或 长 度。加入 const 的作用倒不是怕 调 用者修改，而是防止 编 写函数的人不小心改 动 了 对 象。因 为 百密 总 有一疏，万一在某个不 该 修改数据的函数中改 变 了数据（比如将 “==” 写成 “=” ），或者万一 调 用了另一个非 const 的成 员 函数都将可能引起 错误 。在 编 写函数前就先加上 const 可以 记编译 器来帮你 检查 。
　　 这 个 const 加在形参表的后面 显 得有些怪怪的，造成 “ 怪怪的 ” 原因就是因 为 函数的形参表中没有 this ，也就没有能用 const 来修 饰 的 东 西了。林 锐说 “ 大概是因 为 其它地方都已 经 被占用了 ” 并不是根本原因。

 

标题： ：内 联 函数

内 联 函数 应该 是 为 了改善 C 语 言中的宏替 换 的不足而 产 生的吧。因 为 宏替 换 是 预编译 中直接展 开 的，展 开过 程中将 产 生意想不到的 结 果。 典型的有 “#define MAX(a, b) (a) > (b) ? (a) : (b)” 。 “result = MAX(i, j)+2;” 将被展 开为 “result = (i) > (j) ? (i) : (j) + 2;” 。 虽 然外面再加一 对 括号可以解决以上 问题 ，但是 “result = MAX(i++, j);” 被展 开 后将 导 致 i 被自增 1 了两次。 （以上例子摘自林 锐 博士的《高 质 量 C++/C 编 程指 南》第 66 页 ，林 锐 管 这 叫做 “ 边际 效 应 ” ）
　　 C++ 用内 联 来取代宏替 换 ，大大提高了安全性。 虽 然内 联 函数也是 编译时 展 开 的，但是它能 进 行安全 检查 ， 还 能 处 理 类 的成 员 函数（原因是内 联 函数能 够处 理 this 指 针 ，宏却不能）。
　　引用：内 联对编译 器来 说 只是一个建 议 ， 编译 器可以 选择 忽略 这 个建 议 。
　　笔 记 ：也就是 说 ，有些函数你想内 联 ， 编译 器也不一定会采 纳 。因 为 内 联 函数 虽 然减少了函数 调 用的 开销 ，却增加了程序的体 积 。
　　内 联 函数是唯一允 许实 体多次被 编译 的函数。原因是 编译 器必 须 先 编译这 个函数体，才能在 编译 函数 调 用的地方 进 行合 理地展 开 。 这 就 说 明在多个 CPP 文件 组 成的工程中，可能有不止一个 CPP 文件中要有函数的 实 体。 既然 这样 ，就放 进头 文件吧 。

对 本文本的 评论 有：

我 觉 得象 这 个 max() 和以前的数 组 越界一 类 的事 , 都可以 归纳为 一句 话 , 那就是 ,C 为 我 们 提供了 强 大的工具 , 那些不会使用的人才会出 现这种错误 . 连 个数 组 越界也管理不好的 , 还 是去写武侠小 说 比 较 好 .
比如火 药发 明了以后 , 我 们 可以用来炸山 开 路什 么 的 , 难 道因 为 有人用于 战 争 , 就怪 这 个火 药 功能不 够 完善 吗 ?

是这样的，我们不应该怪C标准不好，
虽然它不能让result = MAX(i++, j);这种问题得到解决，
产生i被自增两次这样的结果，程序员应该自己去避免。
但是，如果标准有进步了，我们倒是因为祝贺它一下。

 

 

标题： ：局部 对 象与静 态 局部 对 象

本 节 首先向 读 者 说 明了 “ 名字的作用域 ” 和 “ 对 象的生命周期 ” 这 两个概念，不 难 ，理解了就行了。前者是空 间 概念：指程序 还处 在代 码阶 段的 时 候 这 个名字的可 见 范 围 ，后者是 时间 概念：指程序运行 过 程中 对 象的存在 时间 。
　　函数的形参以及函数内部声明的 对 象都是局部 对 象，它 们 的作用域就是函数内部，但是它 们 的生命周期却未必是函数的 执 行 过 程。 这 看起来有点摸不着 头脑 ，原因在于 C++ 的函数中允 许 存在以 关键 字 “static” 声明的静 态对 象。
　　也就是 说 ，静 态对 象是 这样 一个 对 象：它的生命周期很 长 ，可以跨越 该 函数的 每 次 调 用，哪怕 该 函数 每 24 小 时 才 调 用一次，它也是全天候存在的。但是要想 访问 她，却只有函数正在 执 行的 时 候才行。
　　 签 于以上特性，我 专门 写了两个 测试 函数， 该 函数 试 途返回局部 对 象的引用或指 针 ：
int& GetInt()
{
　　 int t=3;
　　 return t;// 警告
}

int* GetInt2()
{
　　 int t = 3;
　　 return &t;// 警告
}
　　以上两个警告 产 生的原因是函数返回了 临时对 象的引用或地址。但是如果将 t 的声明改成 “static int t=3;” 就不再 显 示警告。
　　静 态 局部 对 象似乎 为节约 系 统开销 做了准 备 。不 过 我 认为这 个特性不 应该 被 滥 用。只有确 实 有必要 让对 象生 命周期跨越多次 调 用 时 才 应该 把它声明 为 静 态 （比如 统计 函数被 调 用的次数）。否 则 将提高造成 BUG 的可能性，使 “ 高效率 ” 的程序成 为 空中楼 阁 。

标题： ：默 认实 参

没什 么 比 偷懒 更舒服的了，所以我喜 欢 允 许 默 认实 参的函数，我 还 喜 欢 写允 许 默 认实 参的函数。
　　在形参表中，如果允 许 某些形参具有默 认值 ， 则 它 们 必 须 按从右到左的方向排列。以上 这 个 规 定 C++ 与 BASIC 是一 样 的，但是 C++ 与 BASIC 还 有一点区 别 ，就是在函数 调 用 时 ， C++ 必 须 从右 边开 始缺省 实 参，而 BASIC 却可以任意缺省而不 顾 次序（只要有逗号表示那里缺了个 东 西即可）。所以，同 样设计 函数， C++ 比 BASIC 要多考 虑 一个 问题 ： “ 设计带 有默 认实 参的函数，其中部分工作就是排列形参，使最少使用默 认实 参的表参排在最前，最可能使用默 认实 参的形参排在最后。 ”
　　形参的默 认值 竟究写在声明中 还 是 实 体中？我曾 经试过 ，在某 些情况下写在声明中或 实 体中一 样 可行。但是，事 实 上写在 实 体中是 错误 的做法。只有当函数 实 体和函数 调 用在同一个源文件中，而且函数 实 体在 调 用前被 编译时 ，将形参的默 认值 写在 实 体中才可通 过编译 。 实际 上 对 于 这种 情况，函数根本就不用声明。
　　将默 认值 写在 实 体中不 仅仅 是能否通 过编译 的 问题 ， 还关 系到程序 设计 的理念。 “ 一是函数的 实现 本来就与参数是否有缺省 值 无 关 ，所以，没有必要 让 缺省 值 出 现 在函数的定 义 体中。二是参数的缺省 值 可能会改 动 ， 显 然修改函数的声明比修改函数的定 义 要方便。 ” （《高 质 量 C++/C 编译 指南》第 63 页 ）
　　 读 到 这 里，本 书给 了我一个大大的惊 诧 ：原来默 认实 参的默 认值还 可以是任何表达式。以前，我一直是 这样 写的： “int GetInt(int i=3);” 虽 然没人跟我 这样说过 ，但是我始 终 以 为 后面的默 认值 只能是常量。想不到 还 可以是需要求 值 的 变 量甚至是更 复杂 的表达式：
int GetInt(const int i = 3);
int GetInt2(const int j = GetInt());// 居然可以 这样 写
　　学 习 了，感 谢 《 C++ Primer 》！

 

标题： ：函数的声明与 实 体

注：本 书 中提到了 “ 声明 ” 与 “ 定 义 ” 两个 词 。我倒是 认为 将后者改 为 “ 实 体 ” 更好。
　　函数的 实 体就是 实实 在在的函数内容，它 规 定了 这 个函数怎 样执 行， 这 没有什 么 好 说 的。那 么 函数 为 什 么还 要有声明呢？
　　 这样 做的目的之一是告 诉编译 器： 虽 然你 还 没有 见 到函数本身，不知道函数是怎 样执 行的，但是我先告 诉 你 这 个函数的名称、参数与返回 值 ，你就先 编译 吧。至于 这 个函数究竟干什 么 ，等到 连 接的 时 候再 说 。
　　 设计 合理的程序，其代 码 存放在不同的文件中，函数的 实 体只能有一个，存放在某一个源文件中。其它源文件中如果要用到 这 个函数，就在 这 个文件中加入函数的声明。
　　 这样 做的目的之二是函数的提供者与使用者往往不是同一个人，甚至不是同一个企 业 。出于 种种 目的，函数的提供者可能并不想（或不必） 让 使用者知道 这 个函数的具体内容，只要使用者能 调 用就行。 这种 情况下，函数的提供者只需要提供一个声明 给 使用者即可。 ——C 语 言的 库 函数就是 这样 的。
　　然而 “ 在需要用到函数的文件中加入函数的声明 ” 也有好 办 法与笨 办 法。将声明 语 句重写一遍自然 不 难 ，但是 这样 做有两个明 显 的缺点：一是 烦琐 易 错 、二是不易修改。所以，函数的声明 应该 放在 头 文件中，哪儿要，就在哪儿包含。 这 就好像我家没有 摆许 多盆 鲜 花而是 摆 了 许 多面 镜 子。我在哪儿都能看到 鲜 花， 浇 水却只要 浇 一盆。
　　 这 个理 论 也适用于 C++ 的 “ 类 ” ， 类 的声明写 进头 文件，而 实 体却写 进 程序文件。不同的是， 类 的声明不像函数的声明那 样 只有一句 话 ，而是一个完整的 结 构 。

 

 

标题： ： 递归

引用：直接或 间 接 调 用自己的函数称 为递归 函数。
　　引用： 递归 函数必 须 定 义 一个 终 止条件，否 则 函数将永 远递归 下去， 这 意味着函数会一直 调 用自身直到程序耗尽。
　　初 识递归 的 时 候，的确有些不容易搞明白。 记 得当 时 的教科 书为 此画一个 图 ，用一 组 箭 头 来表示要 计 算 A 必 须 先 计 算 B 、要 计 算 B 又要先 计 算 C 、 …… ，用另一 组 箭 头 表示算好了 C 就可以算 B 、算好了 B 就可以算 A 。 …… 实 例程序与一个 图结 合，如此 摆 事 实讲 道理，要 说 明 递归 自然稍容易些。
　　要写 递归 函数就得 领 悟 递归 的妙用，要写没有 错误 的 递归 函数 则 要 领 悟其数学原理。我倒是 觉 得 这样 的函数与 “ 数学 归纳 法 ” 有些相通之 处 。不同的是，数学 归纳 法 总 是先求 边 界条件，再去往无 穷 方向 归纳 。而 递归 是从无 穷 方向向 边 界 计 算的。函数如何 执 行，与我 们 如何写没有必然的 关 系，于是，我 们 在写程序的 时 候也可以先写 边 界条件。 这样 做可以在程序 开头 先把可能的 问题给 排除掉。 “ 永 远递归 下去 ” 的可能性自然被降低。比如求 阶 乘的函数：
// 程序一、 书 上的例子
int factorial(int val)
{
　　 if (val > 1)
　　　　 return factorial(val-1);
　　 return 1;
}
// 程序二
int factorial2(int val)
{
　　 if (val <= 1)
　　　　 return 1;
　　 return factorial2(val-1);
}
　　程序二的写法与程序一没有区 别 ，但可以告 诉 自己 递归 必 须 有 终 止条件。防止一不小心就写了个 “ 永 远 ” 。
　　似乎 绝 大多数 递归 函数都可以用循 环 来解决。 这 两 种 方法迁就了不同的 对 象：循 环 用少量的 计 算机 资 源、大量的人力来解决 问题 ， 递归则 用大量的 计 算机 资 源、少量的人力来解决 问题 。所以，在 计 算机速度和存 储 量都不大的年代，曾有人反 对递归 。
　　 汉诺 塔 问题 据 说 是只有用 递归 才可以解决的 问题 ，其 实 只有要求解 汉诺 塔的移 动过 程才必 须 用 递归 ，如果只要求解移 动 次数，那 么 用循 环 也不成 问题 。

对本文本的评论有：

阶乘的函数写错了.
int factorial(int val)
{
　　if (val > 1)
　　　　return val* factorial(val-1);
　　return 1;
}

晕，我忘了相乘了，哈哈。

 

标题： ： return 语 句

引用： return 语 句用于 结 束当前正在 执 行的函数，并将控制 权 返回 给调 用此函数的函数。
　　引用： return 语 句有两 种 形式： reutrn; return expression;…… 第二 种 形式提供了函数的 结 果。
　　笔 记 ：以上第一句 话说 了 return 的两个作用之一： 结 束函数。 return 的作用之二是提供函数的返回 值 。
　　 对 于 return 语 句的两 种 形式，情式一只能用于无返回 值 的函数，情式二可以用于有返回 值 的函数也可用于无返回 值 的函数。
　　如果函数有返回 值 ，就必 须 用形式二来 结 束， 这 是 显 而易 见 的。
　　 对 于没有返回 值 的函数，可以不写 return 语 句， “ 隐 式的 return 发 生在函数的最后一个 语 句完成 时 ” 。也可以用形式一来 结 束， 这种 用法一般用在函数中 间 ，判断某些条件之后就立即 结 束，后面的 语 句不再 执 行。如果用形式二来返回，那 么 express 必 须 是另一个没有返回 值 的函数。如：
void FuncA();
void FuncB()
{
　　 return FuncA();
}
　　个人 认为这种 写法不是好 习惯 ，因 为 看起来 FuncB 有了返回 值 ，如果 逻辑 上有 这 需要，我 认为 写成以下格式更好：
void FuncB()
{
　　 FuncA();
　　 return;
}
　　在 BASIC 中，函数的返回 值 与 结 束是由两个不同的 语 句 实现 的。前者是一个 给 函数名 赋值 的 语 句，后者 则 是 “Exit Function” 语 句。 这种设计 除了不如 C++ 精 练 以外， 还 容易出事。比如在函数 开头 先 给 函数名 赋 一个默 认值 ，然后根据某些条件 给 它 赋 其它特定的 值 并 Exit 。如果写函数 时 不小心漏了某个 赋值语 句，函数将 产 生 BUG 。 C++ 则 不会 产 生 这种类 型的 BUG 。
　　引用：千万不要返回局部 对 象的引用。
　　引用：千万不要返回局部 对 象的指 针 。
　　笔 记 ：以上两句是黑体的 标题： ， 书 中 专门进 行了 讨论 。不 过这 个 错误虽 然 严 重，却不 难 理解。知道了就好了。
　　 main() 是一个很特殊的函数，它的特殊性在 这 里 还 有体 现 。引用： “ 返回 类 型不是 void 的函数必 须 返回一个 值 ，但此 规则 有一个例外的情况：允 许 主函数 main 没有返回 值 可 结 束。 …… 编译 器会 隐 式地插入返 回 0 的 语 句。 ”

 

标题： ： 传递 数 组 的函数与字符串函数

如果将数 组 作 为实 参来 调 用函数，函数接收到的形参其 实 是一个指 针 。数 组 名是可以 转换为 指 针 的，但是数 组 名和指 针毕 竟不等价。所以， 这样传递 的 结 果是 丢 失了数 组 原有的一些特性。最大的 损 失莫 过 于 sizeof 对 数 组 大小的 测试 。 试 看以下程序：
void FuncA(int *temp)
{
　　 cout << sizeof(temp) << endl;
}
void FuncB(int temp[])
{
　　 cout << sizeof(temp) << endl;
}
void FuncC(int temp[20])
{
　　 cout << sizeof(temp) << endl;
}
int main()
{
　　 int a[10];
　　 cout << sizeof(a) << endl;
　　 FuncA(a);
　　 FuncB(a);
　　 FuncC(a);
　　 return 0;
}
　　三个函数的写法各有不同，但是 结 果却是一 样 的。其中 FuncC 的写法尤其容易 产 生 误 解。因 为编译 器不管你 传递 的是多大的数 组 （甚至不管是不是数 组 ），但是函数的写法却在暗示程序 员这 个数 组 有 20 个成 员 。如果 实 参成 员 超 过 20 个， 结 果就是 没有起到完全的作用，如果 实 参成 员 不到 20 ，那就指 针 越界了。
　　 为 避免 这样 的 尴 尬，有 时 我 们 将指 针 与容量一起 传 入函数： “void FuncD(int temp[], _size_t Size);” ，或者 传递 两个指 针 ： “void FuncE(int* Begin, int* End);” 。 这样 做当然好，不 过 C++ 还 有另一 种办 法可以不用 这么 麻 烦 ，那就是引用 传递 ： “void FuncF(int (&temp)[10]);” 。 这样 的函数只允 许 将 int[10] 实 参 传 入，大小不符的数 组 或非数 组 的指 针 都无法 传 入。 这样 就保 证 了 10 这 个 值 的正确性， 连 sizeof 都省了。
　　 C 语 言的字符串 处 理函数大概是 仅 有的可以不受此 约 束的函数了。字符串就是字符数 组 ，但是在 传递 字符数 组时 ，可以只 传 指 针 而不管大小。因 为 C 语 言中的字符串都是以 NULL 尾的。前 阵 子有人在 论坛 提 问 ， 问 及字符串和字符指 针 的 关 系。回答是： C 语 言的字符串是用字符数 组 存放的，而 处 理 则 是借助于字符指 针 。但是，要能 进 行 这样 的操作，有两个条件必 须满 足：一是所有字符 连续 放置在以指 针开头 的内存中、不跳 跃 ，二是有一个 规 定的 结 束符。 int[] 数 组 之所以不能 这样 做，是因 为 第二个条件无法 满 足 。

 

标题： ：函数的引用返回 值

引用是 给变 量取一个 别 名，所以引用 传递 会直接 进 行 变 量本身的 传递 。它的最大好 处 是可以把 别处对变 量的改 变 保留下来，第二好 处 是它提高了性能：如果函数的返回 值 是一个引用，那 么 ，如上文所 说 ，它会 节约 一 组 构造、 赋值 和析构 过 程。但是，函数返回引用往往会 带 来一些意想不到的 错误 ：比如返回 临时变 量的引用。
// 一个 错误 的函数
int &Max(int i, int j)
{
　　 return i>j ? i : j;
}
　　以上函数的 错误 在于， i 和 j 在函数 结 束后会被 释 放。 对 它 们 的引和也将失效。如果用 这 个返回 值给别 的 变 量 赋值 ，将会 获 得一个垃圾。 VC++.Net 会 对 以上 return 语 句 显 示警告。
　　那 么 ，如果返回一个全局 变 的引用呢？ 这 当然是可以的，但是，一来程序 设计 中不建 议 使用 过 多的全局 变 量，二来全局 变 量即使不返回也可以 访问 。 这样 做的唯一用途就是把函数做右 值 来 给 其它 变 量 赋值 。
int m;// 全局 变 量
int &MaxByGlobal(int i, int j)
{
　　 return m = i>j ? i : j;
}
int a, b, c;
c = MaxByGlobal(a, b);// 用法一、用返回 值赋值
MaxByGlobal(a, b); c = m;// 用法二、不用返回 值赋值
　　当然，以上 这 个 MaxByGlobal 函数也不是一无是 处 ，能用返回 值 来 进 行 赋值 会 给 程序 带 来更好的可 读 性。 只是 这样 的函数 设计 本身不被建 议 。
　　那 么 ，函数返回引用用得最多的就是返回形参了。因 为 形参可以用引用 传递 ，引用的形参不是函数内部的局部 变 量， 这样 做是可取的：
int &MaxByRef(int &i, int &j)
{
　　 return i>j ? i : j;
}
　　上面 这 个函数和上文中的 “int Max(int i, int j)” 函数如此相似，但是它省去了三次构造、 赋值 和析构。
　　另外一 种 用法就是在 类 的成 员 函数中返回 类对 象自身了，典型的是 “operator +=” 函数之 类 。
MyClass &MyClass::operator +=(const MyClass &other)
{
　　 // 某些 语 句
　　 return *this;
}
　　以上函数返回的是自身的引用。因 为类 的成 员 函数也可以写成全局函数 “MyClass &operator +=(MyClass &Left, const MyClass &right)” ，而且在 类 成 员 函数的 调 用中 实际 存在着 this 指 针 的 传递 。所以，以上 这 个函数依然可以看作返回了形参的引用。
　　 对 于返回引用的函数， 还 有一个好玩的 现 像。即返回 值还 可能可以被 赋值 。如 “(a += b) = c;” 这样 的形式。 这种 写法明 显 不 伦 不 类 ，但是如果函数返回了非 const 的引用， 这 个表达式的确是合理的。所以，上面的 “operator +=” 函数 还 要修改一下，将返回 值 由 “MyClass&” 改 为 “const MyClass&” 。
　　返回引用并不是 处处 可用的，正如《引用 传递 的 应 用范 围 》中提到的一 样 ：不能用引用来 传递临时值 。有 时 候我 们 的确要 产 生一个 临时对 象并返回它，那就不能返回引用。典型的有 “operator +” 函数：
const MyClass MyClass::operator +(const MyClass &other) const
{
　　 MyClass Temp;
　　 // 某些 语 句
　　 return Temp;// 这 里只能返回 对 象，因 为 Temp 必 须 是局部 变 量
}

 

标题： ：函数的非引用返回 值

函数最多可以返回一个 值 ，也可以不返回任何 值 （也有 “ 返回 void” 的 说 法）。之所以最多只能返回一个 值 ，因 为 只有 这样 才能在表达式中使用。比如 “y=Sin(x);” ，如果 Sin 函数返回多个 值 ， 这 个表达式就失去了意 义 。之于 为 什 么 可以不返回任何 值 ， 经历过 BASIC 的人 应该 更能理解。因 为 BASIC 中把有返回 值 的程序段叫函数，没有返回 值 的程序段 则 叫做 “ 子程序 ” 。很 显 然， “ 子程序 ” 就是完成一个特定的功能后 结 束的程序段。
　　函数的返回 值 没有 类 型限制，可以是内置 类 型 变 量，也可以是 类对 象。无 论 是内置 类 型 还 是 类对 象，都有着 一 样 的 规 律。但是， 这 些 规 律在 C++ 到来之前很少有人去理会， 毕 竟内置 变 量 类 型太 复 通，以至于程序 员 根本不去考 虑 那 么 多 “ 为 什 么 ” 。
　　在 C 时 代，所有的返回 值 都是局部 变 量。如下列程序：
// 程序一：
int Max(int i, int j)
{
　　 return i>j ? i : j;
}
// 程序二：
char *StrCpy(char *Target, const char *Source)
{
　　 char *Temp=Target;
　　 while(*Source)
　　 {
　　　　 *Temp++ = *Source++;
　　 }
　　 return Target;
}
　　程序二 给 人一个 错觉 ： 认为该 函数返回的不是函数内部的局部 变 量。 错误 原因在于没有理解指 针 的本 质 。其 实 程序二和程序一一 样 ，返回 值 是形参之一。而形参就是作用域 为 函数内部的局部 变 量。
　　理解了 “ 返回 值 是局部 变 量 ” 还 不 够 。因 为还 有一个很重要的概念没弄清。比如：
int a, b, c;
char d[10], e[10], *f;
// 其它 语 句
c = Max(a, b);// 语 句一
f = StrCpy(d, e);// 语 句二
　　以上注 释 的 两行 语 句都有同一个 问题 ：如果返回的 变 量作用域 仅 限于函数内部，那 么 函数 结 束以后 该变 量就已 经 不存在了，那 么给 c 和 f 赋值 的是什 么 ？
　　 C 和 C++ 有一个机制保 证 以上 赋值 正常 进 行：在函数 结 束前，先将要返回的局部 变 量 临时 拷 贝 一份到 栈 内存（ 这 个内存程序 员 无 须 知道，也无法知道）。然后将局部 变 量 销毁 ，函数正常 结 束。接下来用 栈 中的 临时变 量 对 目 标变 量 进 行 赋值 ， 赋值结 束后再把 临时变 量 销毁 。
　　以上 这 个 过 程凭空多出一次 变 量构造、 复 制与 销毁过 程，好在 对 于内置 类 型 变 量来 说 ， 这样 的 过 程所需的性能 赋 出并不太多。但是 C++ 到来以后，函数的返回 值类 型可以是 类类 型。而 类对 象的构造、 复 制与 销毁 可能很 复杂 、很占用系 统资 源。于是 “ 引用 传递 ” 再一次 发挥 了它的威力 。

 

标题： ：引用 传递 的 应 用范 围

经过 三篇文章的 细 述，函数的参数 传递应该 比 较 明朗了， 经过 一番 对 比，似乎引用 传递 是最 优 秀的一 种传递 方式。第一、它用法很 简单 ， 类 似于 值传递 ，第二、它功能很 强 大， 类 似于指 针传递 ，第三、它很安全，可以避免指 针传递带 来的危 险 ，第四、它效率高，函数中不必要 进 行 对 象的 创 建、 赋值 与 释 放。第五、如果不希望 实 参被改 变 ，可以使用 const 修 饰 形参 ……
　　但是，天下没有 这么 便宜的午餐！引用 传递 不是倒 处 能用的。 举 个例子：
void Swap(int& a, int& b)
{
　　 int temp = a;
　　 a = b;
　　 b = temp;
}
　　以上函数可以 进 行两个 int 变 量的交 换 。但是，很多情况下 该 函数不能 调 用：
int ia = ib = 1;
short sa = sb = 2;
const int cia = cib = 3;
Swap(ia, ib);// 正确
Swap(sa, sb);// 错误 ， short 不是 int ， 虽 然可以 隐 式 转换为 int ，但是 这 个 变 量不存在
Swap(cia, cib);// 错误 ， 这 两个参数是 const 的
Swap(4, 5);// 常量不是 变 量， 类 似于将 short 变 量 传递给 函数
Swap(ia+ib, ia-ib);// 错误 ，表达式求 值 后 产 生的 临时值 不是 变 量
　　其中将 const 参数 传递进 函数的做法， 虽 然看起来有些荒 诞 ， 实际 上某些 时 候会不 经 意 间 做的。某个 变 量在定 义 的 时 候并不是 const 的，但是在 调 用某个函数的 时 候将它作 为 const 形参 传 入，而 该 函数内部再 调 用 Swap() 函数 时 ， 这 个 变 量已 经 成了局部的 const 变 量。
　　以上 这 个特性反 过 来 应 用是很有用的。在多人 协 作写程序的 时 候，或者写一个大型程序的 时 候。你不知道某函数是否用 const 来保 护 参数，但是你想保 护 参数。那 么 ，你就在自己写的原 调 函数中将 该 参数保 护 起来。 这样 ，当你 调 用某个没有 显 式指定 const 引用参数的函数 时 ， 编译 器就会 报错 。
void funca(const int& a)
{
　　 funcb(a);// 发 生 错误
}
void funcb(int& b)
{
　　 ...;
}
int t;
funca(t);
以上程序会在注 释 的那行停止 编译 。因 为 在它 调 用了函数 b ，而 b 没有声明参数 为 const 。 虽 然函数 b 中未必改 动 参数 。

 

 

标题： ：形参与 实 参的 关 系之引用 传递

C++ 有了 “ 引用 传递 ” 后， “ 形参的改 变 不影响 实 参 ” 被判无效。因 为传递给 函数的并不是一个 值 ，而是 变 量自身。在函数中定 义 的形参 虽 然 还 是局部 变 量，但却是一个引用。 虽 然 这 个引用的作用域 仅 限于函数内部，但是由于它与 实 参就是同一回事，所以 对 它的操作完全等同于 对实 参的操作。比如你叫 “ 黑旋 风 ” 去 买鱼 ，或者叫 “ 铁 牛 ” 去 买鱼 ，去的都是同一个人。
　　 C++ 为 什 么 要有 “ 引用 传递 ” 这 回事？一 种说 法是只有引用才能达到操作符重 载 的目的， 这 个以后再 谈 。但是，撇 开这 个不 谈 ，形参是不是引用，直接影响了程序 执 行的效率。前面提到 过 ，函数 调 用 时 要用 实 参的 值 去初始化形参，初始化的 过 程包含了定 义 一个 变 量、然后 给 它 赋 一个 值 两个 过 程，如果 这 个 变 量并不是内部 变 量，而是一个 类对 象，那 么 ，定 义 一个 类对 象可能很 复杂 ，而初始化 这 个 对 象一 样 会很 复杂 。而引用只是 给对 象取一个 别 名，不 涉 及定 义 与初始化，离 开 作用域 时 也不用 释 放。
　　相比之下，用指 针传递 可以避免 类对 象的定 义 、初始化与 释 放。只需要付出指 针变 量的定 义 、初始化与 释 放的代价。但是，指 针 的 杀伤 力太大。即使是熟 练 的程序 员 ，也不能保 证绝 不出 现 “ 野指 针 ” ，野 针 的代价几乎无一例外是程序崩 溃 。
　　引用也不是吃素的，如果 说 指 针传递 是 “ 帮你配了一把我家的 钥 匙 ” ，那 么 引用 传递 就是直接把我家的 财产 都交 给 了你。有 时 ，我 们 使用引用 传递仅仅 是 为 了效率，而不希望 实 参被修改，那就要 记 得把形参 标记为 const ，如 “UINT GetLength(const CString&)” 。
　　 顺 便 说 一句，指 针传递 也可以 这样 做。把形参定 义为 指向 const 对 象的指 针 （而不是 const 指 针 ），可以降低 杀伤 力，保 护实 参所 对应 的内存。如果是普通的 值传递 ，那 么 有没有 const 对 函数外 部并不影响。但是，我个人 认为 ，有 时 候加上 const 也是一件好事。如果程序的 逻辑 并不需要改 变 参数，而 实际 上 误 写了代 码 ，加上 const 可以 让编译 器帮我 们 找出 BUG ，如：
int Max(const int a, const int b)
{
　　 return a>b?a:b;
}
　　 VB 没有指 针 的概念，却有 “ 值传递 ” 和 “ 地址 传递 ” 两个概念。比如 “Function Func(ByRef i As Integer) As Integer” ， 变 量 i 接受了 实 参后，它的改 变 能影响 实 参。它的 实质 就 类 似于 C++ 中的引用 传递 。

 

 

标题： ：形参与 实 参的相互 关 系

“ 形参的改 变 不影响 实 参 ” 这 句 话说 起来 轻 巧，但是要完全理解，似乎 还 有几个玄机。
　　在我 发 表《函数的定 义 》一文后，有朋友 发 表意 见 ，提到了 “ 函数 调 用 过 程中的入 栈 与出 栈 ” ，在此首先作个 说 明：我 读 的是《 C++ Primer 》，而不是《 编译 原理》，入 栈 与出 栈 不 归 我 讨论 。在 现 在 讨论 的尺度内，我 们 可以 这么认为 ：形参是函数内部的一个局部 变 量， 该 局部 变 量在函数 开 始 执 行 时 被初始化，而初始化它的 值则 来自 实 参的 值 。也就是 说 ，它的定 义 与初始化 类 似于 “int i=3;” 。只是被分成两行写了，形参的定 义 写在函数的定 义 中，如： “int ttt(int b)” ，初始化写在了 调 用中 “cout << ttt(a) << endl;” 。 —— 参看上一篇文章《形参与 实 参概念》。
　　那 么 ，在函数中无 论 怎 样 改 动 b 的 值 ，被改的始 终 是形参 这 个局部 变 量，函数 结 束 时 ，离 开这 个局部 变 量的作用域， 变 量被 释 放。
　　但是， C 语 言的 “ 指 针传递 ” 总 是 给 人 “ 形参能改 变实 参 ” 的感 觉 ，其 实这 是一个 误 解。 对 于指 针传递 来 说 ，函数的形参是一个指 针 ， 传给 它的 实 参也 应该 是指 针 （或者能 转为 指 针 的 值 ，比如数 组 名、能 转换为 指 针 的 类 等）。在函数中，如果改 变 了 该 指 针 （ 对 指 针 的改 变 就等同于 让这 个指 针 指向 别处 ），不会影响主 调 函数中的 实 参。但是，由于指 针对应 着一个内存地址，通 过 它可以改 变 内存的内容。所以，无 论 在函数内部的形参 还 是外部的 实 参，它 们 都可以影响同一内存的 值 。所以，指 针传递 可以把函数内部的影响 带 到函数外，但是， 带 到函数外的 绝 不是形参，而是形参所指的内存。
　　 这 就好比我把我家的 钥 匙 给 你配了一把，我手里的 钥 匙是 实 参，你手里的 钥 匙是形参。你无 论 是把 钥 匙折断 还 是磨短，都与我的 钥 匙无 关 ，但是你用它 开 了我家的 门 却可以把我家洗劫一空。你影响的不是我的 钥 匙，而是我的 财产 。
　　上文 说 到， C++ 有了 “ 引用 传递 ” 后， “ 形参的改 变 不影响 实 参 ” 被判无效。 这 就得提到 “ 引用 传递 ” 的概念了，下文再 续 。

对 本文本的 评论 有：

简单 地 说 , 每 次 调 用函数的 时 候 , 形参把 实 参克隆了一次 , 你再怎 么 折 腾 形参 , 也与 实 参无 关 .
TNND 就是一个入 栈 与出 栈过 程嘛 , 你可以去学学 汇编 .
举 例 :
mov cs1,100 //cs1=100;
push cs1 // 把 cs1 入 栈 ;
pop cs2 // 把 栈 中的内容出 栈给 cs2;
这 与另一句 话 等价 :
mov cs1,100
mov cs2,cs1
为 什 么 会使用上面的那 种 用法呢 ?
因 为 push 和 pop 占用更少的 CPU 周期 . 所以 , 一般 调 用函数都用入 / 出 栈 来 备 拷 贝 参数 .

 

 

 

标题： ：形参与 实 参概念

说 到形参与 实 参，在 C++ 出来之前其 实 很 简单 ，就一句 话 ：形参的改 变 不影响 实 参。 这 个状 态 直到 C++ 有了 “ 引用 传递 ” 才有改 变 。
　　要弄清 这 个，首先得弄清形参与 实 参是什 么东 西。因 为 函数是一段 “ 可以重用而不必重写 ” 的代 码 ， 每 次重用当然未必完全相同（不可否 认 有些函数 每 次重用都完全相同），那 么 不同在哪里呢？又怎 样产 生不同呢？一 种 方法是依靠随机，随机是个好 东 西，不要 说 客 户 了， 连 程序 员 都无法控制 每 次 调 用的 结 果。第二 种 方法是凭客 观 条件（比如运行 时间 、机器配置）。但是 这 些函数 应 用很窄， 类 似于 “y=Sin(x)” 这样 的函 数就 绝 不能 这样 做。
　　那 么 ，从 “y=sin(x)” 的形式看来，能决定函数怎 样 运行的唯一因素就是 x 的 值 了。函数的某次运行是受某一个 x 值 的影响并控制的，而下一次运行， 则 会受另一个 x 值 的影响。那 么 ， 调 用函数者就有必要告 诉 函数：我要用哪个 值 来控制你，而函数自己 则 有必要保存 这 个 值 ，直到函数 结 束。
　　 为 此，在函数内部建立一个 临时 的、局部的 变 量， 该变 量的作用域就是函数内部， 该变 量的作用 时间 就是从函数 开 始 执 行到 结 束 执 行。如果同一函数在同一 时间 有几个副本在 执 行（ 这种 情况在多 线 程程序中会出 现 ），那 么 它 们 是互不相干的，它 们 内 部的 变 量也是互不相干的。 这 个 变 量就叫做 “ 形参 ” ，全称形式参数。
　　 “ 形式 ” 是跟 “ 实际 ” 相 对 的，另一个参数就是 实际 参数，叫 “ 实 参 ” ，在 调 用函数 时 ， 这 个 值 将决定函数内部的形参的 值 。 实 参在函数中是否可 见 ？ 这 要取决于两个因素：一是 实 参的作用域，二是有没有被形参覆盖。先 说 第一个因素，如果只 谈 C 语 言，那 么 所 谓 的作用域就是全局与局部两 种 ，但是 C++ 中 还 有 “ 类 作用域 ” 这 一概念，由此第一个因素 变 得 复杂 了。第二个因素本身并不 复杂 ，但是如果没有引起程序 员 的注意，那 么 造成的 问题 是很 难发现 的。 试 看下以下程序：
int a;// 全局 变 量
int ttt(int a)// 该 函数的形参也叫 a
{
　　 cout << ++a << endl;
　　 return a;
}
int main()
{
　　 a = 3;
　　 cout << a << endl;
　　 cout<< ttt(a) << endl;
　　 cout << a << endl;
　　 return 0;
}
　　 该 程序中有一个全局的 a 变 量，但是在 ttt() 函数中却被另一个 a 覆盖了，所以， ++a 没有影响到全局的 a ，如果把函数定 义 改 为 “int ttt(int b)” 则 有不同的 结 果 。
　　以上把 “ 形参 ” 和 “ 实 参 ” 提了 这么 多，主要目的 还 是 讲 清 “ 形参的改 变 不影响 实 参 ” 这 句 话 。字数不少了，留到下篇文章再 续 吧。（我 觉 得我写得不像 读书 笔 记 ，倒像是教材了。 呵呵 ）

 

标题： ：函数的定 义

不 记 得在哪本 书 上看到 过 ，函数的定 义为 “ 有名称的一段代 码 ” 。 这 大概地 说 明了函数的 实质 ：首先、它是一段代 码 ，其次、 这 段代 码 可以被重 复 使用而不必重 复编 写，第三、它是有名字的，在需要重用的 时 候凭名字来 调 用。
　　 这 个 说 法到了 C++ 中 变 得 复杂 了。原因之一是 C++ 支持函数重 载 ，也就是 说 出 现 了同名函数。 虽 然 编译 器在 编译时产 生不同的函数名，但那必竟是 编译 器的事， 对 于程序 员 来 说 就是同一个函数名。原因之二是 C++ 支持运算符重 载 ，可以用一个 类 似于 “+” 号的运算符来 调 用函数。运算符重 载 明 摆 着是 为 了配合 类对 象的运算，因 为 如果没有 类 ， 仅针对 内置 类 型，运算符是没必要重 载 的。 —— 我 试验 了一下，自定 义 了一个 “int operator +(int i, int j)” 函数， 结 果没有通 过编译 。
　　于是，到了 C++ 中，函数的概念被修改 为 “ 函数由函数名以及一 组 操作数 类 型唯一地表示 ” ，依我看， 这样说还 不 够 。 严 格 说 来， 应该说 “ 函数由作用域、函数名以及一 组 操作数 类 型唯一地表示 ” ，理由很 简单 ，因 为 在不同的作用域中可以出 现 名称相同、参数 类 型也相同的函数，除非把 “ 作用域 :: 函数名 ” 合起来看作一个函数名。
　　函数 对 函数体没有任何 强 制性要求，哪怕函数体 为 空也可以。不 过 ，无 论 是空、一句 语 名， 还 是多句 语 句，花括号一定不可少。在 这 里，包括在花括号内的若干行 语 句不能再 视为 一个 复 合 语 句了 —— 因 为 能放 复 合 语 句的地方也能放 简单语 句，而 简单语 句可以不使用花括号。
　　不管你如何看待 这组 花括号，有一点是肯定的：花括号内部是一个作用域。那 么 ，内部定 义 的 变 量就只有在内部使用了。 这 就是局部 变 量，在任何函数（包括 main() ）内部定 义 的 变 量都是局部 变 量 —— 初学者可能以 为 在 main() 内部定 义 的 变 量是全局 变 量。
　　有一 种 内部 变 量的定 义 与以往的定 义 方式不一 样 ，那就是函数的参数。不同之 处 在于：一是它 们 用逗号分隔，二是不允 许 用 “int i,j” 这样 的方式定 义 一 组变 量。我想，也 许 正是因 为 所有定 义 用逗号分隔，才造成不允 许 后者的吧， 毕 竟 这样 会 带 来歧 义 ——j 没有指定 类 型。如果用分号来分隔，那 么 后者的 方式也 许 就可以了。 这 是 C++ 标 准的事，我没有能力来 为标 准出 谋 划策，只能妄加猜 测 了。
　　函数的返回 值 也是一个 类 型，与 变 量的 类 型一 样 ，它可以是内置 类 型，也可以是 类类 型， 还 可以是引用和指 针 。
　　引用：在 C++ 标 准化之前，如果缺少 显 式返回 类 型，函数的返回 值 将被假定 为 int 型。
　　笔 记 ：据我 测试 ，在 VC++.NET 中， 这样 做是可以的。照 这么说 ， VC++.NET 仍然没有按照 C++ 标 准做？或者 说 VC++.NET 迁就了老程序 员 ？

对本文本的评论有：

函数的参数当然不能使用类似int i,j的方式,因为调用函数的时候,涉及到的不仅仅是定义参数,还有把要处理的变量入栈,调用的函数运行前的第一件事,是把被入栈的变量出栈.
这与int i,j定义变量做的事完全不同,所以,不按定义变量的方式写,也很正常.
如果偷猫兄一定要写得一样,那就自己做一个编译器吧.

 

标题： ：函数概念

进 入第七章学 习 。
　　 “ 函数 ” 这 个概念在 C/C++ 里 头 是很 烦 人的。原因在于，好多 C 语 言入 门书 的第一章第一 节 都 说 “C 语 言是由函数 组 成的 ” ，初学者学到 这 里，就好像是 刚 推 开 C 的大 门 就被一个麻袋套在 头 上，什 么 也看不 见 了。那些 书 本 还举 了一个例子，然后 对 照着例子 说 “ 这 个程序是由 main() 、 scanf() 、 printf() 函数 组 成的 ……” 。我 晕 啊，初学者第一天上 C 的 课 ，哪里会管什 么 函数不函数的。
　　 这 点 BASIC 做得不 错 ，倒不是 说 BASIC 比 C++ 好，而是 BASIC 容易入 门 。在 开头 几 节课 不必理会 这么复杂 的 东 西，学了 “Let 语 句 ” 、 “Print 语 句 ” 就可以 涉 足 简单 的算法了。然后提到的 “ 函数 ” 是包括数学函数在内的 “ 内部函数 ” 。我 们 在数学里学 过 “ 函数 ” 概念，知道 “y=Sin(x)” 是一个函数， 现 在在 BASIC 里学到一 样 的函数，自然容易入 门 。等 这 一切都熟悉了，再去学 习 自己写的函数 —— 自定 义 函数，会更加理解程序中的 “ 函数 ” 概念。
　　 VB 与早期的 BASIC 相比，使用了 “ 事件 驱动 ” 原理。画完界面就得面 对 函数了 ，但是 VB 用 “ 事件 ” 这 个 说 法来回避了。初学者可以不知道 “Private Sub Command1_Click()” 究竟代表什 么 ，只要知道那是 “ 按 钮 控件被 单击 后 执 行的代 码 ” 就 够 了。等到后来，学 习 了 “ 自定 义 函数 ” 后，必然会恍然大悟。
　　回到 C++ 中，学 习 之初用到的函数的确是 现 成的 库 函数，但是正因 为过 早地提到了函数概念， 导 致了初学者无所适从。有没有 别 的 办 法呢？当然有了，至少《 C++ Primer 》 这 本 书 一直到第七章才 开 始提 “ 函数 ” 二字。
　　另外： VB 中有 “ 函数 ” 和 “ 子程序 ” 两个不同的概念，如今 “ 子程序 ” 又叫 “ 过 程 ” ，除了使用不同的 关键 字以外，它 们 的惟一区 别 是有没有返回 值 。 C 将它 们 合并了，都叫函数。其 实 ， VB 里的函数也可以 丢 弃返回 值 ，只是 VB 里没有与 “void” 对应 的 词 ，无法定 义 不返 值 的函数，才不得已出此下策 。

 

 

标题： ： try 、 catch 和 assert

程序 员 是要慢慢成 长 的，比如 错误处 理 这种 事情，就不是一 开 始就面 对 的。当我 们编 的程序 还 很小，小到 “cin>>i; cout<<i;” 这样 的程度， 错误处 理不是我 们 要学 习 的目 标 。但是，一旦 开 始 编 写 实 用的程序，那 么 ，无 论 考 虑 多 么 周到，无 论 代 码 多 么 精良。意外 总 是 难 免的。 这 些意外可能来自程序 员 的 设计 不到位、可能来自用 户 的 错误 操作、 还 可能来自机器与网 络 的不确定因素。
　　没有什 么 比追踪 错误 更 难过 的事了， 记 得有一回我在追踪一个 VB 程序的 错误 。 经过长时间测试 ，我 发现 程序在运行中突然 发 生很大的跳 跃 ：函数 A 调 用 B ， B 调 用 C ，在 C 的 执 行 过 程中，居然会突然跳到 A 中。后来追 查发现 ，原来 A 中有一行 “On Error Goto” 语 句。 这 一个 语 句，影响了我 调试 C 函数。从那以后，我明白了，除非程序要 发 布了，否 则别 启 动错误处 理。
　　 C++ 与 VB 不一 样 ， VB 用一句 “On Error Goto” 启 动 了 错误处 理后，在 该 函数 结 束之前一直有效（除非 显 式地 关闭 它）。如果 发 生了异常， 处 理代 码 要根据异常的 值 来分析异常的 类 型。而 C++ 可以 选择 可能出 现 异常的内容放 进 try 后的 块 中。一个函数内部可以有多个 try 块 ，而 每 个 try 块 又可以附 带 多个 catch 来 处 理。 应该说 ， C++ 中的异常 处 理更灵活，当然也更容易出 错 。我前 阵 子 发 生的 错误 就是在 ADO 处 理后只有 “catch(_com_error *e)” ，但是 实际 上出 现 的异常却不是 “_com_error” 类 的， 结 果仍然抓不往异常。
　　异常 处 理和 assert 之 间 的 关 系有些 让 人 难 以捉摸。一方面它 们 各有各的作用，另一方面它 们 有 时 会互相影响。我就曾 经 在 这 上面吃 过亏 ：我的程序是在服 务 器上运行的，从来没人会 盯 着服 务 器看，所以我的程序不允 许弹 出 对话 框。我写了比 较 完善的异常 处 理，无 论 出 现 什 么错误 ，都 记录进 LOG 文件，然后 继续 运行。但是我却 是用 DEBUG 模式 编译 的， 结 果异常到来 时 ， try 没起作用，倒是 assert 起作用了， 弹 了个 对话 框在那儿。 这 件事 给 我的启 发 是： 别 以 为 自己是程序的客 户 就可以用 DEBUG 模式 编译 。

对本文本的评论有：

错误捕捉是很烦人,我的感觉是能在try代码段外解决的错误,就尽量在外头自己解决,尽量少依靠try来处理捕获错误.
在网络编程中,有些错误是无法预知的,比如网络连接断了,数据库当了...好象在这些情况下,用try比较好.
我有一次写的一个服务程序,用户用了一段时间后,经常会异常中止,查来查去查不出原因,后来才发现是ORACLE的日志满了,这个错误显然我在写程序的时候没有想过,丢脸啊...

 

标题： ： break 、 continue 和 goto

break 和 continue 的使用范 围 比 较 一致，两都可以用于循 环 ，其中 break 还 可以用于 switch 。功能上也有一定的相似性， break 就相当于退学， continue 则 相当于跳 级 。 对 于 break ，程序究竟跳到哪儿比 较 好理解。 但是 continue 究竟跳到哪儿去了，初学者可能有些疑惑，不妨就当它跳到了循 环 体最后一句 语 句的后面。
　　如果它 们处 在由多重循 环 和 switch 组 成的圈圈里，那 么 它 们 就 对 包括它 们 的最里 层 起作用。于是， 设 想一下子跳出多重循 环 的人可能忘不了 goto 。
　　引用：从上世 纪 60 年代后期 开 始，不主 张 使用 goto 语 句。 …… 所有使用 goto 的程序都可以改写成不用 goto 。
　　笔 记 ： goto 是一个很有争 议 的 语 句， 语 多 书 本建 议 少用或不用它，我个人的 习惯 是 坚 决不用。不 过 ，至于 “ 上世 纪 60 年代 ” 这 个 说 法，我倒是一直不知道。因 为 我自己学 习 BASIC 已 经 是 1994 年，那 时 候学的是 带 行号的 GW-BASIC ， goto 是必 须 用到的 语 句。莫非当 时 我 们 学校 开设 的 课 程居然是落后二十年的内容？
　　林 锐 博士 对 goto 另有看法，他 说 ： “ 错误 是 程序 员 自己造成的，不是 goto 的 过错 。 goto 至少有一 处 可 显 神通，它能从多重循 环 中咻地一下子跳到外面， …… 就像房子着火了，来不及从楼梯一 级 一 级 往下走，可从窗口跳出火坑。 ……” （《高 质 量 C++/C 编 程指南》第 32 页 ）
　　我写的程序目前 还 没有超越三 级 循 环 。从最里 层 往外跳，如果跳一 层 ，就 break ，如果跳两 层 或三 层 ，一是 这种 可能性很小，二是如果真的碰到了，我就用其它条件来控制外 层 循 环 是否 继续 break ，自从 1997 年 进 入 结 构化的程序 设计 以来，我的确完全抛弃了 goto 。 ——VB 中的 “On Error Goto” 除外，出 现错误 ，自然不管在哪一 层 ，都 给 我跳 进错误处 理中。
　　 goto 的目 标 是一个 标 号， 这 个 标 号的起名倒有点意思，因 为标 号只用于 goto ，所以它的名字可以与任何 变 量名以及其它 标识 符一 样 而不 产 生重名。以前的程序是 带 行号的，所以就 “goto  行号 ” ， 现 在程序不 带 行号了，但是允 许 在任何地方加 标 号。 编译 器在碰到它 们 的 时 候，大概就是凭其后 头 的冒号来判断 这 个名字不需要 检验 合法性。那 么 ， C++ 中已有的 “public:” 算不算 标 号呢？
　　 为 此，我做了个 实验 ： 实验 内容一是我在 类 的声明里加入了一行 “pub:” ，二是我在程序段中加入了一行 “public:” 。 结 果 发现 两都都不能通 过编译 。也就是 说 ， 实验 一 说 明在 类 定 义这样 的地方不允 许 使用 标 号（也用不着，因 为 它不在任何函数内部， goto 是运行 时 的事，与 编译 无 关 ，而且 goto 不允 许 跨函数跳越。）， 实验 二 说 明在程序段中的 标 号不允 许 使用保留字 。

对本文本的评论有：

不主张使用GOTO语句是为了让程序看起来顺眼而己.看:模块化的代码.其实的确没什么大不了的.记住,当你的程序被编译成机器代码以后,里面的跳转全是JMP,相当于GOTO.

 

自从和草莓对骂以来，你就学会了狡辩。
我有跟你讨论机器码吗？
程序设计的风格是为了程序维护，
不是为了编译。

 

标题： ： while 、 for 语 句

while 中有一个怪事： 类 似于 “while (int i = GetInt())” 这样 的 语 句，在条件中定 义 一个 变 量，在 for 中非常常 见 ，也很好理解。但是用在 while 中却有所不同，如果用在 while 中，那 么每 次循 环 都会 经历 一次 创 建和撤 销 的 过 程。 —— 天， 还 是不要 这样 写吧。幸 亏 我 总 是在 while 前面定 义 并初始化 变 量的。
　　 do-while 与 while 有着不一般的 关 系，所以几乎所有的 书 本都是把它 们 放一起 讲 的。当年学 BASIC 时 ，花了不少的功夫去学 习 “ 当型循 环 ” 和 “ 直到型循 环 ” 。的确，当型和直到型都有存在的必要，因 为 程序的确有 这 两 种逻辑 需要。于是 C 、 BASIC 以及 PASCAL 等程序 语 言都提供了 这 两 种 循 环 。不 过 提供 归 提供，怎 么 用却是程序 员 自己的事。就我个人而言，我 还 是喜 欢 用当型循 环 。因 为 当型循 环 可以模 拟 出直到型循 环 的效果来。比如以下四段代 码 ，它 们 是完全一致的：
// 代 码 1
do
{
　　循 环 体 ;
　　 BoolVal =  表达式 ;
}while (BoolVal);
// 代 码 2
BoolVal = 1;// 先 赋 True 值
while(BoolVal)
{
　　循 环 体 ;
　　 BoolVal =  表达式 ;
}
// 代 码 3
do
{
　　循 环 体 ;
}while ( 表达式 )
// 代 码 4
while(1)
{
　　循 环 体 ;
　　 if (! 表达式 ) break;
}
　　 for 语 句的 执 行 顺 序和 执 行 逻辑 是最 难讲 清的了。如果知道了，就是 这么 回事。如果不知道，不 费 上半天口舌是 说 不清的。原因在于 for 包括四个互相 关联 的 语 句，其中三个在 “for” 后面的括号里，另一个作 为 循 环 体存在。 这 也 难 怪 BASIC 要将 for 语 句定 义为 “For i=M To N Step t” 的格式。
　　 for 括号里的三个 语 句是可以省略的，最牛 B 的省略莫 过 于 “for (;;)” 了。会 这样 写的人，要 么 是 彻彻 底底地明白了 for 的 逻辑 的人，要 么 是一点不懂的人。我 觉 得，如果要我 这样 写，我不如写 “while(1)” 了。

 

 

标题： ： if 、 switch 语 句

本 书 不愧 为经 典 书 ，在 if 这 地方能避免 说 教， 讲 得 绘 声 绘 色，真叫人佩服。
　　大体上 if 要注意的就只有 else 的配 对问题 了。如果在 else 前方有多个没有配 对 的 if ，那就找最近的一个配 对 。如果要改 变这种 默 认 的 “ 拉郎配 ” ，就加上花括号。
　　 还 是引用林 锐 博士的一句 话 吧： “if 、 for 、 while 、 do 等 …… 不 论执 行 语 句有多少都要加 {} 。 这样 可以防止 书 写失 误 。 ” （《高 质 量 C++/C 编 程指南》第 16 页 ）
　　 if 语 句曾有一个令我疑惑 了好久的 东 西： “else if” 究竟算什 么 ？因 为 BASIC 里有 “ElseIf” 这 个 关键词 ，而 C++ 中所 谓 的 “else if” 是两个 关 健 词组 成的。中 间 插了个空格。我 们 都知道， C++ 的 语 句与 语 句之 间 插入若干个（包括 0 个）空格、 TAB 、回 车 都是一 样 的，那 么 ，如果我把 else 后插入一个回 车 ，不成了另一 种结 构的 if 语 句了 么 ？后来我仔 细 地分析一下 逻辑关 系，才豁然 开 朗：原来是 BASIC 的 “ElseIf” 干 扰 了我的理解。 C++ 中用哪 种 方法去理解都没区 别 。
　　都 说 switch 是 为 了 简 化 if 而出 现 的，但是 switch 虽 然可以 简 化 if ，却并不是任何 时 候都能使用。使用 switch 有两个先决因素：一是所有的条件都必 须 是 编译时 常量。也就是 说 如果要在程序运行 时 再决定 case 后的条件，那是不行的。另一个因素是只能拿出若干个整数 值 来比 较 是否相等，既不能是浮点数，也不能比 较 大于或小于。
　　 switch 最容易出 错 的就是 丢 失 break 语 句了。因 为 按常 规 思路，人 们总 以 为 两个 标 号之 间 的 语 句才是 应该执 行的。从 BASIC 过 来的人更加痛苦，因 为 BASIC 里不需要 类 似于 break 这样 的 语 句来表示 结 束。
　　我的做法是，在打程序框架 时 ，先把 case 标 号和 break 写了，其余的再去完善。即使 逻辑 上不需要 break 语 句，也要写上 “//break;” ， 这样 可以提醒自己和 团队 的伙伴：此 处 并未 丢 失 break ，而是的确不需要。
　　 丢 失 default 是最理直气壮的了。因 为 的确有 许 多 时 候并不需要 default ，但是我的 经验 是要加上 default 以及它后面的 break ，原因同上，提醒自己和伙伴我没有 遗 漏 。

 

标题： ： 简单语 句与 复 合 语 句

祝 贺进 入第 6 章的学 习 。
　　 简单语 句就是只有一句的 语 句， “ 复 合 语 句 ” 也叫 语 句 块 ，是由多句 语 句 组 成的一个整体。 虽 然 BASIC 也有 语 句 块 的概念，但是它 们 却是不同的概念： BASIC 将 简单语 句 视为 特殊的 语 句 块 ，而 C++ 则 将 语 句 块视为 特殊的 简单语 句。个人 认为 ， C++ 中 复 合 语 句的存在是 为 了 补 充 C++ 没有 “end if” 之 类语 句的缺陷。
　　 BASIC 中， if 有 end if （行 if 除外）、 while 有 wend ， do 有 loop 。也就是 说 ，有 头 就有尾，所以， BASIC 编译 器不担心无法确定 语 句 块 的大小。 C++ 则 不同，它的 这 些 关键 字都没有 结 束 语 句。没有 结 束 标记 ， 谁 知道它的主体究竟是几行呢？所以， C++ 只好 规 定：所有 这 些 结 构的 语 句体都只能包含一句，而且必 须 包含一句（有且 仅 有一句）。 换 句 话说 ，如果要多句，你也得做成一句的 样 。
　　将多行做成一行，就是所 谓 的 “ 复 合 语 句 ” 了。
　　 说 到 简单语 句，空 语 句和空 块 是不能不提的。空 语 句（ 块 ）也是 语 句（ 块 ），只是它 啥 也不干。空 语 句存在的原因，无非也是因 为 C++ 中 规 定了 语 句体必 须 是一句。 刚 才 说 了，那些 结 构的 语 句体是 “ 有且 仅 有一句 ” ，不 仅仅 “ 多于一句要写成一句的 样 ” ，反 过 来 说 ，如果没有任何内容，你 也得 伪 造一句出来。于是 “ 空 语 句 ” 问 世了。
　　以下 语 句就是一个典型的例子：
int s = 0;
for (int i=1,s=0; i<101; s+=i,++i) ;// 空 语 句
　　空 语 句的存在 为 C++ 徒增了 难 度与危 险 性，很多初学者弄不清哪些 语 句要以分号 结 尾，哪些 语 句不要， 错误 地在 for() 后面加了个分号， 结 果使循 环 体被取消了循 环 的 资 格，而且有可能出 现 死循 环 。

 

 

标题： ： 显 式 转换

引用： 显 式 转换 也称 为强 制 类 型 转换 。
　　笔 记 ：我 觉 得要提 强 制 类 型 转换 ，得从 C 风 格的 说 起。 这 里面可能有我个人的原因。因 为 我个人 习惯 了 C 风 格的 强 制 类 型 转换 。
　　在 C 语 言中， 强 制 类 型 转换 就是用借助一 对 括号同 时 把 类 型名和表达式列出来，比如 “(int)t” 和 “int(t)” 就是把 t 转为 int 型。
　　引用：因 为 要覆盖通常的 标 准 转换 ，所以需 显 式使用 强 制 类 型 转换 。 …… 显 式使用 强 制 类 型 转换 的另一个原因是：可能存在多 种转换时 ，需要 选择 一 种 特定的 类 型 转换 。
　　笔 记 ：从外文 图书 翻 译过 来的中国 图书 有个通病，就是 语 言不 伦 不 类 。本 书 算是翻 译 得非常好的了，依然无法 摆 脱 这种 影响。上文的意思无非是 说 ：我不希望使用默 认 的 转换规则 的 时 候，就可以 显 式地 规 定按我的要求 转换 。如果要 举 个例子，可以拿上文《 类 型 转换 之 隐 式 转换 》中一个 现 成的例子：
int a = -3;
unsigned b = 3;
if (a == b)// 隐 式 转换 将 转为 unsigned int
if (a == (int)b)// 显 式指定 转换为 int
　　 这种 用法更多地用于指 针类 型的 转换 。因 为 指 针类 型就是指 针 所指向 对 象的 类 型，而指 针 本身是没有 类 型区 别 的。所以，指向任何 类 型的指 针 可以互相 转换 。最典型的就是 void* 和其它 类 型之 间 的互 换 了，比如： “int* p = (int*)malloc(sizeof(int) * MaxSize);”
　　 还 有一 种 用法就是在 编译 器不允 许进 行 隐 式 转换 的 时 候，比如将 const 对 象 转为 非 const 对 象。如：
const int t = 3;
int* p = (int*)&t;// 本来要写作 const int* p = &t;
　　 这种 用法 还 是少用 为 好，理由很 简单 ， 编译 器之所以不允 许进 行 转换 ，就是 为 了保 护 数据，你非要破坏 这种 安全性自然不好。即使能确信 这样 做不 产 生 恶 果， 这样 做至少是没有良好 风 格的。
　　 C++ 中 为显 式 类 型 转换 提供了四 种 不同的操作符： static_case 、 dynamic_cast 、 const_cast 、 reinterpret_cast 。个人 认为 与 C 风 格的相比似乎都没有什 么进步 。
　　引用： 强 制 类 型 转换关闭 或挂起了正常的 类 型 检查 。 强 烈建 议 程序 员 避免使用 强 制 类 型 转换 ，不依 赖强 制 类 型 转换 也能写好很好的 C++ 程序。

 

 

标题： ： 类对 象的 隐 式 转换

与算 术类 型相比， 类 的 转换 更 复杂 。因 为 算 术转换 只 涉 及到精度的 问题 ，而 类对 象的 转换 却 涉 及到能否 转换 以及怎 样转换 的 问题 。
　　 隐 式 转换 就是 隐 式 转换 ，它会出 现 在你没有注意的地方。参看以下代 码 ：
class CMyInt
{
public:
　　 CMyInt();
　　 CMyInt(int i);
　　 ~CMyInt();
private:
　　 int m_i;
};
CMyInt::CMyInt()
{
　　 m_i = 0;
　　 cout << " 无参数构造 ( 默 认 0)" << endl;
}
CMyInt::CMyInt(int i)
{
　　 m_i = i;
　　 cout << " 从整数构造 , 值为 " << i << endl;
}
CMyInt::~CMyInt()
{
　　 cout << " 析构 " << m_i << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
　　 CMyInt a;
　　 a = 3;
　　 return 0;
}
　　 执 行以上代 码 会 发现 ，程序中有两次构造与两次析构，原因是 “a = 3;” 这 个 赋值 表达式要将右 边 的 类 型 转换为 左 边 的 类 型。 而 这 个 转换 是通 过调 用构造函数来 进 行的。
　　不 过 ，以上代 码 只是 测试 用的， 读 者 们 千万不要在 实际 工作中写 这样 的代 码 。因 为这样 做是很不科学的。 “a = 3;” 这样 的表达式，只要 CMyInt 类 提供了右 值类 型 为 int 的 赋值 操作符重 载 ，就可以避免使用构造函数来 进 行 转换 。操作符重 载 代 码 如下：
　　在 类 定 义 的 public 段添加一行： “CMyInt& operator = (const int i);” 然后在 类 定 义 外部添加以下代 码 ：
CMyInt& CMyInt::operator = (const int i)
{
　　 m_i = i;
　　 cout << "operator =" << i << endl;
　　 return *this;
}
　　加了以上代 码 ，同 样 是 “a = 3;” 就不使用 类 型 转换 了，改 为 使用 赋值 操作。我写下以上 这 段程序的目的只是 验证 VC++ 中会有 类对 象的 转换 ，它 们 与算 术类 型的 转换 差不多：生成一个合适的 临时对 象，参与运算以后再把 临时对 象 释 放掉 。

标题： 重 载 函数再 论

重 载 函数是 C++ 提出来的概念，但是在 C 中却未必没有。比如 “1+3” 和 “1.0+3.0” ， 虽 然都是加法，做的却不是同的操作： 编译 器要因操作数的不同而 调 用不同的加法操作。只是 C 语 言中除了内部 类 型 变 量可以参与运算以外，没有 “ 类 ” 这么 高深的概念。 “ 结 构体 ” 也只是内存数据的 组织 方法，而不 涉 及 对 整个 结 构体的 处 理。所以，在 C 语 言 时 代 编译 器明明做了 类 似于重 载 的事情，却可以像雷 锋 一 样 “ 做好事不留名 ” 。
　　 C++ 发 展出了 类 ，并且 赋 予了 “ 类 ” 很高的期望， 类 的 对 象也能像内置 类 型 对 象一 样 参与一切运算。那 么 ，就拿加法运算来 说 ， 编译 器如何知道 对 某 类对 象的加法 该调 用哪一个 详细 的操作代 码 ？于是，即使不出 现 普通函数的重 载 ，至少运算符是要重 载 的。
　　林 锐 博士在《高 质 量 C++/C 编 程指南》中 为 重 载 函数的必要性提了另一个理由： 类 的构造函数名称必 须 与 类 名相同，而 类 却 经 常要定 义 多个不同的构造函数。那就只好重 载 了。
　　 对 于普通程序 员 来 说 ，我 们 完全可以不用考 虑 得 这么 深。重 载 函数 给 我 们 至少 还带 来了另一个好 处 ：不用 记忆 多个不同的函数名了，也不用 为 了 给 函数起名而 绞 尽 脑 汁了。不 过 本 书还给 出了一个建 议 ：并不是任何 时 候都有必要重 载 函数的，有的 时 候不同的函数名可 以直 观 地 带 来好多信息， 滥 用重 载 只是 牺 牲了名称中的信息。

 

标题： ：重 载 函数的概念

引用：出 现 在相同作用域中的两个（可以是两个以上 —— 偷 猫注）函数，如果具有 相同的名字而形参表不同， 则 称 为 重 载 函数。
　　本 节开头 第一句 话 就 给 出了重 载 函数的定 义 ：重 载 函数必 须 符合两个条件：一是出 现 在相同的作用域中、二是函数名字相同而形参表不同。
　　其中第一个条件一般人往往是不去想的，其 实 函数名相同而作用域不同的函数大大存在，比如在 MFC 中就有。它 们 是完全不相干的函数。
　　第二个条件 还 可以 详说 一下：函数名字相同当然不在 话 下， 这 是函数被称 为 “ 重 载 ” 的根源。之于形参表不同，可能表 现 在形参个数不同、可能表 现 在形参 类 型不同、 还 可能表 现 在形参 顺 序不同。
　　如果要 扩 展 开 来 说 ， 还 可以 举 出 许 多 不是重 载 函数的情况。
　　一、如果既在同一作用域下、名称也相同、形参表也相同， 则 后者被 视为 前者的重 复 声明。 —— 函数可以重 复 声明，因 为 函数的声明并不 产 生目 标 代 码 ，但是函数的定 义 不允 许 重 复 出 现 。
　　二、如果既在同一作用域下、名称也相同、形参表也相同，但是返回 值 不同， 则 后者被 视为错误 的声明。函数不可以只凭返回 值 来区分，因 为调 用函数的 时 候只凭名称和形参来 选择 函数，而不凭返回 值 。再究其原因，一是因 为 函数的返回 值 可以被 丢 弃；二来即使不 丢 弃，将返回 值赋 予另一个 变 量之前没必要 检查 我需要什 么样 的返回 值 ，而能否 赋值 也与函数本 身无 关 。
　　三、有些 时 候看起来形参表不同， 实际 上是完全相同的， 书 本第 229 页讲 了四 组这样 的例子：
Record lookup(const Account &acct);
Record lookup(const Account &);// 区 别 在于有没有 给 形参命名
typedef Phone Telno;
Record lookup(const Phone&);
Record lookup(const Telno&);// 只是 给类 型取了个 别 名
Record lookup(const Phone&, const Name&);
Record lookup(const Phone&, const Name& = "");// 区 别 在于 给 形参提供了默 认值
Record lookup(Phone);
Record lookup(const Phone);// 区 别 在于是否 const 　　
　　其中第三 组 可能会 让 人 产 生函数的形参个数不同的假像，其 实 可缺省的形参并没有减少形参的个数。第四 组 有点不容易搞清：因 为 有的 时 候可以凭是否 const 来重 载 ，比如引用 传递 和指 针传递 。

 

标题： ：文件的 组织

一个程序往往由多个源文件 组 成， 这 些代 码 究竟 应该 放在哪个源文件里、哪些代 码 可以放在同一个源文件里、哪些代 码 必需分 开 放。 这 是一个管理 层 面的 问题 。
　　 说 它是管理 层 面的 问题 ，是因 为这 些代 码 的 组织 往往没有惟一的准 则 。但是它 们还 是有一定的 规 律的。
　　首先， 软 件的 维护 是一个 复杂 的系 统 工程。代 码 的 组织应该 有利于 维护 。 应该 尽量把直接相 关 的内容放在同一文件、不相 关 的内容放在不同的文件里。如果 这 些代 码还 有 亲 和疏，那就要分不同的文件 夹 来存放了。
　　其次， 软 件的代 码 是一个 严 格的 组织 体系。不同的内容之 间 可能是并列的，也可能有必要的先后 关 系。于是在 “#include” 的 时 候要注意 顺 序。
　　最后，也是最重要的一点，有些代 码 在同一工程中可以重用（或必 须 重用），有些代 码 在同一个工程中只能出 现 一次。可以重用的有 类 的声明、函数的声明、 变 量的声明等，不可以重用的是 类 的 实 体、函数的 实 体、 变 量的定 义 等。那 么 ，把可以重用的内容放在 h 文件中，把不可以重用的放在 cpp 文件中是一个好 办 法。
　　拿 类 的声明和 类 的 实 体 为 例，如果把一个 类 的所有内容一古 脑 放在同一个文件中，将可能出 现问题 。因 为 在其它用到 类实 例的地方都必 须让类 的声明 “ 可 见 ” ，所以我 们 往往在文件 头 部加个 “#include” ， 结 果 类 的 实 体也被 编译 多次，在 连 接 时产 生冲突。
　　在前文中曾提到 过 ，内 联 函数是惟一允 许 （也是必 须 ）在 编译时让 函数 实 体可 见 的的函数。所以内 联 函数可以放在 h 文件中。 C++ 规则 中有一句正好与此照 应 ：在 类 的声明中直接写出的函数被 认为 是内 联 函数。
　　 Visual C++ 给类 的文件起默 认 名 时 ，文件名往往与 类 名一致。如果 类 名由 “C” 开头 ， 则 文件会是除去 开头 的 “C” 字以外的其它文字。如 类 “CMyClass” ，它的代 码 存放在以下两个文件中： “MyClass.h” 和 “MyClass.cpp” 中。原因是 VC++ 建 议类 名以 C 开头 ，至于 为 什 么 在文件名中不出 现开头 的 “C” ，可能是出于微 软 的 习惯 吧 。

 

标题： ： 类 的构造函数

引用：构造函数是特殊的成 员 函数。
　　笔 记 ：构造函数的确是一 类 “ 特殊 ” 的成 员 函数。它的特殊性至少表 现 在以下几个方面：一是它的 调 用不用程序 员 操心，只要 类对 象被 创 建它就会被 调 用，而且它不允 许 被程序 员显 式地 调 用。二是它 们 是必需的，如果程序 员偷懒 ， 编译 器将自 动创 建 简单 的构造函数。三是它 们 的名字不用程序 员 多考 虑 ，直接与 类 名相同。四是它 们 没有返回 值 。
　　下面 详说这 几个特性：
　　一、它 们 在 类对 象被 创 建 时 自 动调 用， 创 建 对 象可能有以下方法：程序中用声明 变 量的 语 句直接声明 创 建，或者在程序中用 new 关键 字 动态创 建。 这 两 种 方法都可以 创 建 单 个 对 象，也都可以 创 建 对 象数 组 。只要有一个 对 象被 创 建，构造函数就被 调 用一次。
　　如果程序 员 想 显 式地 调 用构造函数那是不行的。正因 为 如此，构造函数中 还 有一 种 特定的部分叫 “ 初始化列表 ” ，通 过 它程序 员 可以 调 用基 类 或成 员 的构造函数。必竟 类 的 设计 千差万 别 ，如果某个 类 的基 类 或（和）成 员 有多个构造函数，那 么 ， 该类 必 须 能 够 指定用哪一个构造函数，否 则类 的功能将大打折扣。 调 用构造函数不是程序 员 的事，程序 员 不 应该 管也管不了。初始化列表 为 解决 这 个 问题 而生，所以只有构造函数才有初始化列表，其它函数不能有。
　　上面 说 到的 “ 大打折扣 ” 究竟是怎 样 的折扣呢？如果 不能指定基 类 和成 员 用哪一个构造函数，那就只好 让编译 器去挑了，构造出来的 对 象往往不符合要求，只好 调 用基 类 和成 员 的其它函数，比如 赋值 函数或其它 进 行参数 设 定的函数 —— 当然，基 类 和成 员 必 须 包含 这样 的函数。 这样 就浪 费 了 资 源。
　　二、 类 必 须 包含构造函数 —— 确切地 说 是必 须 包含无参数构造函数和拷 贝 构造函数 —— 原因是因 为 它 们 的 调 用是自 动 的。如果 这 两个函数根本就没有，你 让 系 统 如何 调 用？所以， C++ 也不含糊，你要是 懒 得写，它就帮你写一个 简单 的。 简单 就意味着至少要 丧 失一些功能，如果 类设计 得比 较复杂 （比如包含指 针 操作） 还 可能引起灾 难 性事故。
　　三、函数名与 类 名一致。构造函数的名称是必 须 特殊的，即使 这 个特殊不表 现 在与 类 名相同，也必 须 找到另一个 规则 来 实现 。因 为 系 统 要自 动调 用 这 些函数，你就必 须让 系 统 知道哪些函数是构造函数。
　　第四个特性直接改 变 了 C/C++ 语 言的一条 规则 ： C 语 言 规 定，如果函数没有明 显 指出返回 类 型，那 么 C 语 言 认为 返回 值 是 int 型。 C 语 言之所以可以有 这 条 规则 ，一是因 为 返回 int 的函数很多，二是因 为 即使没有返回 值 ，也必 须 指明 void 。当 时 制定 规则 的人无法 预 料到， C++ 中居然会出 现 “ 连 void 都不是的返回 值 ” 的函数， void 虽 然表示不返回任何 值 ，必竟与 类 构造函数的 “ 没有返回 值 ” 是两 码 事。于是， C++ 新 标 准 规 定：在定 义 或声明函数 时 ，没有 显 式指定返回 类 型中不合法的。当然 类 的构造函数除外。
　　构造函数的出 现 有它的可行院 捅 厝恍浴？尚行允怯捎 贑 ++ 的 类 允 许 包含成 员 函数，既然 类 可以包含普通的成 员 函数，那 么 包含特殊的函数自然也不在 话 下。必然性是由于 类 的 对 象往往必 须经过 特定的初始化。 C++ 到来之前， C 语 言中的数据 类 型只是内置 类 型。 对 于内置 类 型 对 象，如果忘了初始化，大不了 这 个 对 象失去作用，但是不会 导 致大的 问题 。比如一个 int 型 值 ，无 论 内存如何随 机，它的取 值 范 围 都不会超 过 int 能表达的范 围 ， 对 它 进 行运算也不会 产 生危 险 （溢出不能算危 险 ，即使初始化 过 的数据也不能保 证 不溢出，而且溢出只是一 种逻辑问题 ）。但是 现 在的 类 不 这么简单 了，忘了初始化往往将 带 来运行 错误 。于其 每 次都要考 虑 数据的初始化， 还 不如把 这 个初始化写成 统 一的函数， 让 系 统 自 动调 用来得既安全又方便 。

 

 

标题： ： 类 的成 员 函数

类 与 C 语 言中的 结 构体最大的区 别 就是 类 可以 带 函数，而 结 构体只是一个内存 组 合 。所以，要提 类 就不得不提成 员 函数。
　　 类 的成 员 函数与普通函数（全局函数）相比，最根本的区 别 是 实现 了 类 的封装性。封装性的第一个表 现 是 访问权 限：都是函数，但是你能 访问 哪个不能 访问 哪个却可以 设 定。第二个表 现 是直 观 ，通 过类 成 员 （或指 针 ）来 调 用函数， 给 人的直 觉 就是 “ 这 是 类 提供的功能 ” 。你好像 “Bird.Fly();” 一 样 一目了然。
　　在理解 this 指 针 以前要想 彻 底理解成 员 函数是有困 难 的，我就曾以 为 在 类 的 实 例中保存了函数的副本。要不然， 为 什 么 同一个 类 的不同 对 象 调 用 这 个函数有不同的效果呢？原来，在函数所有的形参之外， 还 有一个不用你操心的参数 this ，它是一个指 针 ， 该 指 针 的目 标 就是函数的 调 用者。 这么 一 说 就明白了。
　　函数形参表后加入 const 就成了 “const 成 员 函数 ” ， 这样 的函数保 护 了 调 用者自身不被修改。如 CString 的 GetLength() 函数，你只能 获 取它的 长 度，不能修改它的内容或 长 度。加入 const 的作用倒不是怕 调 用者修改，而是防止 编 写函数的人不小心改 动 了 对 象。因 为 百密 总 有一疏，万一在某个不 该 修改数据的函数中改 变 了数据（比如将 “==” 写成 “=” ），或者万一 调 用了另一个非 const 的成 员 函数都将可能引起 错误 。在 编 写函数前就先加上 const 可以 记编译 器来帮你 检查 。
　　 这 个 const 加在形参表的后面 显 得有些怪怪的，造成 “ 怪怪的 ” 原因就是因 为 函数的形参表中没有 this ，也就没有能用 const 来修 饰 的 东 西了。林 锐说 “ 大概是因 为 其它地方都已 经 被占用了 ” 并不是根本原因。

 

标题： ：内 联 函数

内 联 函数 应该 是 为 了改善 C 语 言中的宏替 换 的不足而 产 生的吧。因 为 宏替 换 是 预编译 中直接展 开 的，展 开过 程中将 产 生意想不到的 结 果。 典型的有 “#define MAX(a, b) (a) > (b) ? (a) : (b)” 。 “result = MAX(i, j)+2;” 将被展 开为 “result = (i) > (j) ? (i) : (j) + 2;” 。 虽 然外面再加一 对 括号可以解决以上 问题 ，但是 “result = MAX(i++, j);” 被展 开 后将 导 致 i 被自增 1 了两次。 （以上例子摘自林 锐 博士的《高 质 量 C++/C 编 程指 南》第 66 页 ，林 锐 管 这 叫做 “ 边际 效 应 ” ）
　　 C++ 用内 联 来取代宏替 换 ，大大提高了安全性。 虽 然内 联 函数也是 编译时 展 开 的，但是它能 进 行安全 检查 ， 还 能 处 理 类 的成 员 函数（原因是内 联 函数能 够处 理 this 指 针 ，宏却不能）。
　　引用：内 联对编译 器来 说 只是一个建 议 ， 编译 器可以 选择 忽略 这 个建 议 。
　　笔 记 ：也就是 说 ，有些函数你想内 联 ， 编译 器也不一定会采 纳 。因 为 内 联 函数 虽 然减少了函数 调 用的 开销 ，却增加了程序的体 积 。
　　内 联 函数是唯一允 许实 体多次被 编译 的函数。原因是 编译 器必 须 先 编译这 个函数体，才能在 编译 函数 调 用的地方 进 行合 理地展 开 。 这 就 说 明在多个 CPP 文件 组 成的工程中，可能有不止一个 CPP 文件中要有函数的 实 体。 既然 这样 ，就放 进头 文件吧 。

对 本文本的 评论 有：

我 觉 得象 这 个 max() 和以前的数 组 越界一 类 的事 , 都可以 归纳为 一句 话 , 那就是 ,C 为 我 们 提供了 强 大的工具 , 那些不会使用的人才会出 现这种错误 . 连 个数 组 越界也管理不好的 , 还 是去写武侠小 说 比 较 好 .
比如火 药发 明了以后 , 我 们 可以用来炸山 开 路什 么 的 , 难 道因 为 有人用于 战 争 , 就怪 这 个火 药 功能不 够 完善 吗 ?

是这样的，我们不应该怪C标准不好，
虽然它不能让result = MAX(i++, j);这种问题得到解决，
产生i被自增两次这样的结果，程序员应该自己去避免。
但是，如果标准有进步了，我们倒是因为祝贺它一下。

 

 

标题： ：局部 对 象与静 态 局部 对 象

本 节 首先向 读 者 说 明了 “ 名字的作用域 ” 和 “ 对 象的生命周期 ” 这 两个概念，不 难 ，理解了就行了。前者是空 间 概念：指程序 还处 在代 码阶 段的 时 候 这 个名字的可 见 范 围 ，后者是 时间 概念：指程序运行 过 程中 对 象的存在 时间 。
　　函数的形参以及函数内部声明的 对 象都是局部 对 象，它 们 的作用域就是函数内部，但是它 们 的生命周期却未必是函数的 执 行 过 程。 这 看起来有点摸不着 头脑 ，原因在于 C++ 的函数中允 许 存在以 关键 字 “static” 声明的静 态对 象。
　　也就是 说 ，静 态对 象是 这样 一个 对 象：它的生命周期很 长 ，可以跨越 该 函数的 每 次 调 用，哪怕 该 函数 每 24 小 时 才 调 用一次，它也是全天候存在的。但是要想 访问 她，却只有函数正在 执 行的 时 候才行。
　　 签 于以上特性，我 专门 写了两个 测试 函数， 该 函数 试 途返回局部 对 象的引用或指 针 ：
int& GetInt()
{
　　 int t=3;
　　 return t;// 警告
}

int* GetInt2()
{
　　 int t = 3;
　　 return &t;// 警告
}
　　以上两个警告 产 生的原因是函数返回了 临时对 象的引用或地址。但是如果将 t 的声明改成 “static int t=3;” 就不再 显 示警告。
　　静 态 局部 对 象似乎 为节约 系 统开销 做了准 备 。不 过 我 认为这 个特性不 应该 被 滥 用。只有确 实 有必要 让对 象生 命周期跨越多次 调 用 时 才 应该 把它声明 为 静 态 （比如 统计 函数被 调 用的次数）。否 则 将提高造成 BUG 的可能性，使 “ 高效率 ” 的程序成 为 空中楼 阁 。

标题： ：默 认实 参

没什 么 比 偷懒 更舒服的了，所以我喜 欢 允 许 默 认实 参的函数，我 还 喜 欢 写允 许 默 认实 参的函数。
　　在形参表中，如果允 许 某些形参具有默 认值 ， 则 它 们 必 须 按从右到左的方向排列。以上 这 个 规 定 C++ 与 BASIC 是一 样 的，但是 C++ 与 BASIC 还 有一点区 别 ，就是在函数 调 用 时 ， C++ 必 须 从右 边开 始缺省 实 参，而 BASIC 却可以任意缺省而不 顾 次序（只要有逗号表示那里缺了个 东 西即可）。所以，同 样设计 函数， C++ 比 BASIC 要多考 虑 一个 问题 ： “ 设计带 有默 认实 参的函数，其中部分工作就是排列形参，使最少使用默 认实 参的表参排在最前，最可能使用默 认实 参的形参排在最后。 ”
　　形参的默 认值 竟究写在声明中 还 是 实 体中？我曾 经试过 ，在某 些情况下写在声明中或 实 体中一 样 可行。但是，事 实 上写在 实 体中是 错误 的做法。只有当函数 实 体和函数 调 用在同一个源文件中，而且函数 实 体在 调 用前被 编译时 ，将形参的默 认值 写在 实 体中才可通 过编译 。 实际 上 对 于 这种 情况，函数根本就不用声明。
　　将默 认值 写在 实 体中不 仅仅 是能否通 过编译 的 问题 ， 还关 系到程序 设计 的理念。 “ 一是函数的 实现 本来就与参数是否有缺省 值 无 关 ，所以，没有必要 让 缺省 值 出 现 在函数的定 义 体中。二是参数的缺省 值 可能会改 动 ， 显 然修改函数的声明比修改函数的定 义 要方便。 ” （《高 质 量 C++/C 编译 指南》第 63 页 ）
　　 读 到 这 里，本 书给 了我一个大大的惊 诧 ：原来默 认实 参的默 认值还 可以是任何表达式。以前，我一直是 这样 写的： “int GetInt(int i=3);” 虽 然没人跟我 这样说过 ，但是我始 终 以 为 后面的默 认值 只能是常量。想不到 还 可以是需要求 值 的 变 量甚至是更 复杂 的表达式：
int GetInt(const int i = 3);
int GetInt2(const int j = GetInt());// 居然可以 这样 写
　　学 习 了，感 谢 《 C++ Primer 》！

 

标题： ：函数的声明与 实 体

注：本 书 中提到了 “ 声明 ” 与 “ 定 义 ” 两个 词 。我倒是 认为 将后者改 为 “ 实 体 ” 更好。
　　函数的 实 体就是 实实 在在的函数内容，它 规 定了 这 个函数怎 样执 行， 这 没有什 么 好 说 的。那 么 函数 为 什 么还 要有声明呢？
　　 这样 做的目的之一是告 诉编译 器： 虽 然你 还 没有 见 到函数本身，不知道函数是怎 样执 行的，但是我先告 诉 你 这 个函数的名称、参数与返回 值 ，你就先 编译 吧。至于 这 个函数究竟干什 么 ，等到 连 接的 时 候再 说 。
　　 设计 合理的程序，其代 码 存放在不同的文件中，函数的 实 体只能有一个，存放在某一个源文件中。其它源文件中如果要用到 这 个函数，就在 这 个文件中加入函数的声明。
　　 这样 做的目的之二是函数的提供者与使用者往往不是同一个人，甚至不是同一个企 业 。出于 种种 目的，函数的提供者可能并不想（或不必） 让 使用者知道 这 个函数的具体内容，只要使用者能 调 用就行。 这种 情况下，函数的提供者只需要提供一个声明 给 使用者即可。 ——C 语 言的 库 函数就是 这样 的。
　　然而 “ 在需要用到函数的文件中加入函数的声明 ” 也有好 办 法与笨 办 法。将声明 语 句重写一遍自然 不 难 ，但是 这样 做有两个明 显 的缺点：一是 烦琐 易 错 、二是不易修改。所以，函数的声明 应该 放在 头 文件中，哪儿要，就在哪儿包含。 这 就好像我家没有 摆许 多盆 鲜 花而是 摆 了 许 多面 镜 子。我在哪儿都能看到 鲜 花， 浇 水却只要 浇 一盆。
　　 这 个理 论 也适用于 C++ 的 “ 类 ” ， 类 的声明写 进头 文件，而 实 体却写 进 程序文件。不同的是， 类 的声明不像函数的声明那 样 只有一句 话 ，而是一个完整的 结 构 。

 

 

标题： ： 递归

引用：直接或 间 接 调 用自己的函数称 为递归 函数。
　　引用： 递归 函数必 须 定 义 一个 终 止条件，否 则 函数将永 远递归 下去， 这 意味着函数会一直 调 用自身直到程序耗尽。
　　初 识递归 的 时 候，的确有些不容易搞明白。 记 得当 时 的教科 书为 此画一个 图 ，用一 组 箭 头 来表示要 计 算 A 必 须 先 计 算 B 、要 计 算 B 又要先 计 算 C 、 …… ，用另一 组 箭 头 表示算好了 C 就可以算 B 、算好了 B 就可以算 A 。 …… 实 例程序与一个 图结 合，如此 摆 事 实讲 道理，要 说 明 递归 自然稍容易些。
　　要写 递归 函数就得 领 悟 递归 的妙用，要写没有 错误 的 递归 函数 则 要 领 悟其数学原理。我倒是 觉 得 这样 的函数与 “ 数学 归纳 法 ” 有些相通之 处 。不同的是，数学 归纳 法 总 是先求 边 界条件，再去往无 穷 方向 归纳 。而 递归 是从无 穷 方向向 边 界 计 算的。函数如何 执 行，与我 们 如何写没有必然的 关 系，于是，我 们 在写程序的 时 候也可以先写 边 界条件。 这样 做可以在程序 开头 先把可能的 问题给 排除掉。 “ 永 远递归 下去 ” 的可能性自然被降低。比如求 阶 乘的函数：
// 程序一、 书 上的例子
int factorial(int val)
{
　　 if (val > 1)
　　　　 return factorial(val-1);
　　 return 1;
}
// 程序二
int factorial2(int val)
{
　　 if (val <= 1)
　　　　 return 1;
　　 return factorial2(val-1);
}
　　程序二的写法与程序一没有区 别 ，但可以告 诉 自己 递归 必 须 有 终 止条件。防止一不小心就写了个 “ 永 远 ” 。
　　似乎 绝 大多数 递归 函数都可以用循 环 来解决。 这 两 种 方法迁就了不同的 对 象：循 环 用少量的 计 算机 资 源、大量的人力来解决 问题 ， 递归则 用大量的 计 算机 资 源、少量的人力来解决 问题 。所以，在 计 算机速度和存 储 量都不大的年代，曾有人反 对递归 。
　　 汉诺 塔 问题 据 说 是只有用 递归 才可以解决的 问题 ，其 实 只有要求解 汉诺 塔的移 动过 程才必 须 用 递归 ，如果只要求解移 动 次数，那 么 用循 环 也不成 问题 。

对本文本的评论有：

阶乘的函数写错了.
int factorial(int val)
{
　　if (val > 1)
　　　　return val* factorial(val-1);
　　return 1;
}

晕，我忘了相乘了，哈哈。

 

标题： ： return 语 句

引用： return 语 句用于 结 束当前正在 执 行的函数，并将控制 权 返回 给调 用此函数的函数。
　　引用： return 语 句有两 种 形式： reutrn; return expression;…… 第二 种 形式提供了函数的 结 果。
　　笔 记 ：以上第一句 话说 了 return 的两个作用之一： 结 束函数。 return 的作用之二是提供函数的返回 值 。
　　 对 于 return 语 句的两 种 形式，情式一只能用于无返回 值 的函数，情式二可以用于有返回 值 的函数也可用于无返回 值 的函数。
　　如果函数有返回 值 ，就必 须 用形式二来 结 束， 这 是 显 而易 见 的。
　　 对 于没有返回 值 的函数，可以不写 return 语 句， “ 隐 式的 return 发 生在函数的最后一个 语 句完成 时 ” 。也可以用形式一来 结 束， 这种 用法一般用在函数中 间 ，判断某些条件之后就立即 结 束，后面的 语 句不再 执 行。如果用形式二来返回，那 么 express 必 须 是另一个没有返回 值 的函数。如：
void FuncA();
void FuncB()
{
　　 return FuncA();
}
　　个人 认为这种 写法不是好 习惯 ，因 为 看起来 FuncB 有了返回 值 ，如果 逻辑 上有 这 需要，我 认为 写成以下格式更好：
void FuncB()
{
　　 FuncA();
　　 return;
}
　　在 BASIC 中，函数的返回 值 与 结 束是由两个不同的 语 句 实现 的。前者是一个 给 函数名 赋值 的 语 句，后者 则 是 “Exit Function” 语 句。 这种设计 除了不如 C++ 精 练 以外， 还 容易出事。比如在函数 开头 先 给 函数名 赋 一个默 认值 ，然后根据某些条件 给 它 赋 其它特定的 值 并 Exit 。如果写函数 时 不小心漏了某个 赋值语 句，函数将 产 生 BUG 。 C++ 则 不会 产 生 这种类 型的 BUG 。
　　引用：千万不要返回局部 对 象的引用。
　　引用：千万不要返回局部 对 象的指 针 。
　　笔 记 ：以上两句是黑体的 标题： ， 书 中 专门进 行了 讨论 。不 过这 个 错误虽 然 严 重，却不 难 理解。知道了就好了。
　　 main() 是一个很特殊的函数，它的特殊性在 这 里 还 有体 现 。引用： “ 返回 类 型不是 void 的函数必 须 返回一个 值 ，但此 规则 有一个例外的情况：允 许 主函数 main 没有返回 值 可 结 束。 …… 编译 器会 隐 式地插入返 回 0 的 语 句。 ”

 

标题： ： 传递 数 组 的函数与字符串函数

如果将数 组 作 为实 参来 调 用函数，函数接收到的形参其 实 是一个指 针 。数 组 名是可以 转换为 指 针 的，但是数 组 名和指 针毕 竟不等价。所以， 这样传递 的 结 果是 丢 失了数 组 原有的一些特性。最大的 损 失莫 过 于 sizeof 对 数 组 大小的 测试 。 试 看以下程序：
void FuncA(int *temp)
{
　　 cout << sizeof(temp) << endl;
}
void FuncB(int temp[])
{
　　 cout << sizeof(temp) << endl;
}
void FuncC(int temp[20])
{
　　 cout << sizeof(temp) << endl;
}
int main()
{
　　 int a[10];
　　 cout << sizeof(a) << endl;
　　 FuncA(a);
　　 FuncB(a);
　　 FuncC(a);
　　 return 0;
}
　　三个函数的写法各有不同，但是 结 果却是一 样 的。其中 FuncC 的写法尤其容易 产 生 误 解。因 为编译 器不管你 传递 的是多大的数 组 （甚至不管是不是数 组 ），但是函数的写法却在暗示程序 员这 个数 组 有 20 个成 员 。如果 实 参成 员 超 过 20 个， 结 果就是 没有起到完全的作用，如果 实 参成 员 不到 20 ，那就指 针 越界了。
　　 为 避免 这样 的 尴 尬，有 时 我 们 将指 针 与容量一起 传 入函数： “void FuncD(int temp[], _size_t Size);” ，或者 传递 两个指 针 ： “void FuncE(int* Begin, int* End);” 。 这样 做当然好，不 过 C++ 还 有另一 种办 法可以不用 这么 麻 烦 ，那就是引用 传递 ： “void FuncF(int (&temp)[10]);” 。 这样 的函数只允 许 将 int[10] 实 参 传 入，大小不符的数 组 或非数 组 的指 针 都无法 传 入。 这样 就保 证 了 10 这 个 值 的正确性， 连 sizeof 都省了。
　　 C 语 言的字符串 处 理函数大概是 仅 有的可以不受此 约 束的函数了。字符串就是字符数 组 ，但是在 传递 字符数 组时 ，可以只 传 指 针 而不管大小。因 为 C 语 言中的字符串都是以 NULL 尾的。前 阵 子有人在 论坛 提 问 ， 问 及字符串和字符指 针 的 关 系。回答是： C 语 言的字符串是用字符数 组 存放的，而 处 理 则 是借助于字符指 针 。但是，要能 进 行 这样 的操作，有两个条件必 须满 足：一是所有字符 连续 放置在以指 针开头 的内存中、不跳 跃 ，二是有一个 规 定的 结 束符。 int[] 数 组 之所以不能 这样 做，是因 为 第二个条件无法 满 足 。

 

标题： ：函数的引用返回 值

引用是 给变 量取一个 别 名，所以引用 传递 会直接 进 行 变 量本身的 传递 。它的最大好 处 是可以把 别处对变 量的改 变 保留下来，第二好 处 是它提高了性能：如果函数的返回 值 是一个引用，那 么 ，如上文所 说 ，它会 节约 一 组 构造、 赋值 和析构 过 程。但是，函数返回引用往往会 带 来一些意想不到的 错误 ：比如返回 临时变 量的引用。
// 一个 错误 的函数
int &Max(int i, int j)
{
　　 return i>j ? i : j;
}
　　以上函数的 错误 在于， i 和 j 在函数 结 束后会被 释 放。 对 它 们 的引和也将失效。如果用 这 个返回 值给别 的 变 量 赋值 ，将会 获 得一个垃圾。 VC++.Net 会 对 以上 return 语 句 显 示警告。
　　那 么 ，如果返回一个全局 变 的引用呢？ 这 当然是可以的，但是，一来程序 设计 中不建 议 使用 过 多的全局 变 量，二来全局 变 量即使不返回也可以 访问 。 这样 做的唯一用途就是把函数做右 值 来 给 其它 变 量 赋值 。
int m;// 全局 变 量
int &MaxByGlobal(int i, int j)
{
　　 return m = i>j ? i : j;
}
int a, b, c;
c = MaxByGlobal(a, b);// 用法一、用返回 值赋值
MaxByGlobal(a, b); c = m;// 用法二、不用返回 值赋值
　　当然，以上 这 个 MaxByGlobal 函数也不是一无是 处 ，能用返回 值 来 进 行 赋值 会 给 程序 带 来更好的可 读 性。 只是 这样 的函数 设计 本身不被建 议 。
　　那 么 ，函数返回引用用得最多的就是返回形参了。因 为 形参可以用引用 传递 ，引用的形参不是函数内部的局部 变 量， 这样 做是可取的：
int &MaxByRef(int &i, int &j)
{
　　 return i>j ? i : j;
}
　　上面 这 个函数和上文中的 “int Max(int i, int j)” 函数如此相似，但是它省去了三次构造、 赋值 和析构。
　　另外一 种 用法就是在 类 的成 员 函数中返回 类对 象自身了，典型的是 “operator +=” 函数之 类 。
MyClass &MyClass::operator +=(const MyClass &other)
{
　　 // 某些 语 句
　　 return *this;
}
　　以上函数返回的是自身的引用。因 为类 的成 员 函数也可以写成全局函数 “MyClass &operator +=(MyClass &Left, const MyClass &right)” ，而且在 类 成 员 函数的 调 用中 实际 存在着 this 指 针 的 传递 。所以，以上 这 个函数依然可以看作返回了形参的引用。
　　 对 于返回引用的函数， 还 有一个好玩的 现 像。即返回 值还 可能可以被 赋值 。如 “(a += b) = c;” 这样 的形式。 这种 写法明 显 不 伦 不 类 ，但是如果函数返回了非 const 的引用， 这 个表达式的确是合理的。所以，上面的 “operator +=” 函数 还 要修改一下，将返回 值 由 “MyClass&” 改 为 “const MyClass&” 。
　　返回引用并不是 处处 可用的，正如《引用 传递 的 应 用范 围 》中提到的一 样 ：不能用引用来 传递临时值 。有 时 候我 们 的确要 产 生一个 临时对 象并返回它，那就不能返回引用。典型的有 “operator +” 函数：
const MyClass MyClass::operator +(const MyClass &other) const
{
　　 MyClass Temp;
　　 // 某些 语 句
　　 return Temp;// 这 里只能返回 对 象，因 为 Temp 必 须 是局部 变 量
}

 

标题： ：函数的非引用返回 值

函数最多可以返回一个 值 ，也可以不返回任何 值 （也有 “ 返回 void” 的 说 法）。之所以最多只能返回一个 值 ，因 为 只有 这样 才能在表达式中使用。比如 “y=Sin(x);” ，如果 Sin 函数返回多个 值 ， 这 个表达式就失去了意 义 。之于 为 什 么 可以不返回任何 值 ， 经历过 BASIC 的人 应该 更能理解。因 为 BASIC 中把有返回 值 的程序段叫函数，没有返回 值 的程序段 则 叫做 “ 子程序 ” 。很 显 然， “ 子程序 ” 就是完成一个特定的功能后 结 束的程序段。
　　函数的返回 值 没有 类 型限制，可以是内置 类 型 变 量，也可以是 类对 象。无 论 是内置 类 型 还 是 类对 象，都有着 一 样 的 规 律。但是， 这 些 规 律在 C++ 到来之前很少有人去理会， 毕 竟内置 变 量 类 型太 复 通，以至于程序 员 根本不去考 虑 那 么 多 “ 为 什 么 ” 。
　　在 C 时 代，所有的返回 值 都是局部 变 量。如下列程序：
// 程序一：
int Max(int i, int j)
{
　　 return i>j ? i : j;
}
// 程序二：
char *StrCpy(char *Target, const char *Source)
{
　　 char *Temp=Target;
　　 while(*Source)
　　 {
　　　　 *Temp++ = *Source++;
　　 }
　　 return Target;
}
　　程序二 给 人一个 错觉 ： 认为该 函数返回的不是函数内部的局部 变 量。 错误 原因在于没有理解指 针 的本 质 。其 实 程序二和程序一一 样 ，返回 值 是形参之一。而形参就是作用域 为 函数内部的局部 变 量。
　　理解了 “ 返回 值 是局部 变 量 ” 还 不 够 。因 为还 有一个很重要的概念没弄清。比如：
int a, b, c;
char d[10], e[10], *f;
// 其它 语 句
c = Max(a, b);// 语 句一
f = StrCpy(d, e);// 语 句二
　　以上注 释 的 两行 语 句都有同一个 问题 ：如果返回的 变 量作用域 仅 限于函数内部，那 么 函数 结 束以后 该变 量就已 经 不存在了，那 么给 c 和 f 赋值 的是什 么 ？
　　 C 和 C++ 有一个机制保 证 以上 赋值 正常 进 行：在函数 结 束前，先将要返回的局部 变 量 临时 拷 贝 一份到 栈 内存（ 这 个内存程序 员 无 须 知道，也无法知道）。然后将局部 变 量 销毁 ，函数正常 结 束。接下来用 栈 中的 临时变 量 对 目 标变 量 进 行 赋值 ， 赋值结 束后再把 临时变 量 销毁 。
　　以上 这 个 过 程凭空多出一次 变 量构造、 复 制与 销毁过 程，好在 对 于内置 类 型 变 量来 说 ， 这样 的 过 程所需的性能 赋 出并不太多。但是 C++ 到来以后，函数的返回 值类 型可以是 类类 型。而 类对 象的构造、 复 制与 销毁 可能很 复杂 、很占用系 统资 源。于是 “ 引用 传递 ” 再一次 发挥 了它的威力 。

 

标题： ：引用 传递 的 应 用范 围

经过 三篇文章的 细 述，函数的参数 传递应该 比 较 明朗了， 经过 一番 对 比，似乎引用 传递 是最 优 秀的一 种传递 方式。第一、它用法很 简单 ， 类 似于 值传递 ，第二、它功能很 强 大， 类 似于指 针传递 ，第三、它很安全，可以避免指 针传递带 来的危 险 ，第四、它效率高，函数中不必要 进 行 对 象的 创 建、 赋值 与 释 放。第五、如果不希望 实 参被改 变 ，可以使用 const 修 饰 形参 ……
　　但是，天下没有 这么 便宜的午餐！引用 传递 不是倒 处 能用的。 举 个例子：
void Swap(int& a, int& b)
{
　　 int temp = a;
　　 a = b;
　　 b = temp;
}
　　以上函数可以 进 行两个 int 变 量的交 换 。但是，很多情况下 该 函数不能 调 用：
int ia = ib = 1;
short sa = sb = 2;
const int cia = cib = 3;
Swap(ia, ib);// 正确
Swap(sa, sb);// 错误 ， short 不是 int ， 虽 然可以 隐 式 转换为 int ，但是 这 个 变 量不存在
Swap(cia, cib);// 错误 ， 这 两个参数是 const 的
Swap(4, 5);// 常量不是 变 量， 类 似于将 short 变 量 传递给 函数
Swap(ia+ib, ia-ib);// 错误 ，表达式求 值 后 产 生的 临时值 不是 变 量
　　其中将 const 参数 传递进 函数的做法， 虽 然看起来有些荒 诞 ， 实际 上某些 时 候会不 经 意 间 做的。某个 变 量在定 义 的 时 候并不是 const 的，但是在 调 用某个函数的 时 候将它作 为 const 形参 传 入，而 该 函数内部再 调 用 Swap() 函数 时 ， 这 个 变 量已 经 成了局部的 const 变 量。
　　以上 这 个特性反 过 来 应 用是很有用的。在多人 协 作写程序的 时 候，或者写一个大型程序的 时 候。你不知道某函数是否用 const 来保 护 参数，但是你想保 护 参数。那 么 ，你就在自己写的原 调 函数中将 该 参数保 护 起来。 这样 ，当你 调 用某个没有 显 式指定 const 引用参数的函数 时 ， 编译 器就会 报错 。
void funca(const int& a)
{
　　 funcb(a);// 发 生 错误
}
void funcb(int& b)
{
　　 ...;
}
int t;
funca(t);
以上程序会在注 释 的那行停止 编译 。因 为 在它 调 用了函数 b ，而 b 没有声明参数 为 const 。 虽 然函数 b 中未必改 动 参数 。

 

 

标题： ：形参与 实 参的 关 系之引用 传递

C++ 有了 “ 引用 传递 ” 后， “ 形参的改 变 不影响 实 参 ” 被判无效。因 为传递给 函数的并不是一个 值 ，而是 变 量自身。在函数中定 义 的形参 虽 然 还 是局部 变 量，但却是一个引用。 虽 然 这 个引用的作用域 仅 限于函数内部，但是由于它与 实 参就是同一回事，所以 对 它的操作完全等同于 对实 参的操作。比如你叫 “ 黑旋 风 ” 去 买鱼 ，或者叫 “ 铁 牛 ” 去 买鱼 ，去的都是同一个人。
　　 C++ 为 什 么 要有 “ 引用 传递 ” 这 回事？一 种说 法是只有引用才能达到操作符重 载 的目的， 这 个以后再 谈 。但是，撇 开这 个不 谈 ，形参是不是引用，直接影响了程序 执 行的效率。前面提到 过 ，函数 调 用 时 要用 实 参的 值 去初始化形参，初始化的 过 程包含了定 义 一个 变 量、然后 给 它 赋 一个 值 两个 过 程，如果 这 个 变 量并不是内部 变 量，而是一个 类对 象，那 么 ，定 义 一个 类对 象可能很 复杂 ，而初始化 这 个 对 象一 样 会很 复杂 。而引用只是 给对 象取一个 别 名，不 涉 及定 义 与初始化，离 开 作用域 时 也不用 释 放。
　　相比之下，用指 针传递 可以避免 类对 象的定 义 、初始化与 释 放。只需要付出指 针变 量的定 义 、初始化与 释 放的代价。但是，指 针 的 杀伤 力太大。即使是熟 练 的程序 员 ，也不能保 证绝 不出 现 “ 野指 针 ” ，野 针 的代价几乎无一例外是程序崩 溃 。
　　引用也不是吃素的，如果 说 指 针传递 是 “ 帮你配了一把我家的 钥 匙 ” ，那 么 引用 传递 就是直接把我家的 财产 都交 给 了你。有 时 ，我 们 使用引用 传递仅仅 是 为 了效率，而不希望 实 参被修改，那就要 记 得把形参 标记为 const ，如 “UINT GetLength(const CString&)” 。
　　 顺 便 说 一句，指 针传递 也可以 这样 做。把形参定 义为 指向 const 对 象的指 针 （而不是 const 指 针 ），可以降低 杀伤 力，保 护实 参所 对应 的内存。如果是普通的 值传递 ，那 么 有没有 const 对 函数外 部并不影响。但是，我个人 认为 ，有 时 候加上 const 也是一件好事。如果程序的 逻辑 并不需要改 变 参数，而 实际 上 误 写了代 码 ，加上 const 可以 让编译 器帮我 们 找出 BUG ，如：
int Max(const int a, const int b)
{
　　 return a>b?a:b;
}
　　 VB 没有指 针 的概念，却有 “ 值传递 ” 和 “ 地址 传递 ” 两个概念。比如 “Function Func(ByRef i As Integer) As Integer” ， 变 量 i 接受了 实 参后，它的改 变 能影响 实 参。它的 实质 就 类 似于 C++ 中的引用 传递 。

 

 

标题： ：形参与 实 参的相互 关 系

“ 形参的改 变 不影响 实 参 ” 这 句 话说 起来 轻 巧，但是要完全理解，似乎 还 有几个玄机。
　　在我 发 表《函数的定 义 》一文后，有朋友 发 表意 见 ，提到了 “ 函数 调 用 过 程中的入 栈 与出 栈 ” ，在此首先作个 说 明：我 读 的是《 C++ Primer 》，而不是《 编译 原理》，入 栈 与出 栈 不 归 我 讨论 。在 现 在 讨论 的尺度内，我 们 可以 这么认为 ：形参是函数内部的一个局部 变 量， 该 局部 变 量在函数 开 始 执 行 时 被初始化，而初始化它的 值则 来自 实 参的 值 。也就是 说 ，它的定 义 与初始化 类 似于 “int i=3;” 。只是被分成两行写了，形参的定 义 写在函数的定 义 中，如： “int ttt(int b)” ，初始化写在了 调 用中 “cout << ttt(a) << endl;” 。 —— 参看上一篇文章《形参与 实 参概念》。
　　那 么 ，在函数中无 论 怎 样 改 动 b 的 值 ，被改的始 终 是形参 这 个局部 变 量，函数 结 束 时 ，离 开这 个局部 变 量的作用域， 变 量被 释 放。
　　但是， C 语 言的 “ 指 针传递 ” 总 是 给 人 “ 形参能改 变实 参 ” 的感 觉 ，其 实这 是一个 误 解。 对 于指 针传递 来 说 ，函数的形参是一个指 针 ， 传给 它的 实 参也 应该 是指 针 （或者能 转为 指 针 的 值 ，比如数 组 名、能 转换为 指 针 的 类 等）。在函数中，如果改 变 了 该 指 针 （ 对 指 针 的改 变 就等同于 让这 个指 针 指向 别处 ），不会影响主 调 函数中的 实 参。但是，由于指 针对应 着一个内存地址，通 过 它可以改 变 内存的内容。所以，无 论 在函数内部的形参 还 是外部的 实 参，它 们 都可以影响同一内存的 值 。所以，指 针传递 可以把函数内部的影响 带 到函数外，但是， 带 到函数外的 绝 不是形参，而是形参所指的内存。
　　 这 就好比我把我家的 钥 匙 给 你配了一把，我手里的 钥 匙是 实 参，你手里的 钥 匙是形参。你无 论 是把 钥 匙折断 还 是磨短，都与我的 钥 匙无 关 ，但是你用它 开 了我家的 门 却可以把我家洗劫一空。你影响的不是我的 钥 匙，而是我的 财产 。
　　上文 说 到， C++ 有了 “ 引用 传递 ” 后， “ 形参的改 变 不影响 实 参 ” 被判无效。 这 就得提到 “ 引用 传递 ” 的概念了，下文再 续 。

对 本文本的 评论 有：

简单 地 说 , 每 次 调 用函数的 时 候 , 形参把 实 参克隆了一次 , 你再怎 么 折 腾 形参 , 也与 实 参无 关 .
TNND 就是一个入 栈 与出 栈过 程嘛 , 你可以去学学 汇编 .
举 例 :
mov cs1,100 //cs1=100;
push cs1 // 把 cs1 入 栈 ;
pop cs2 // 把 栈 中的内容出 栈给 cs2;
这 与另一句 话 等价 :
mov cs1,100
mov cs2,cs1
为 什 么 会使用上面的那 种 用法呢 ?
因 为 push 和 pop 占用更少的 CPU 周期 . 所以 , 一般 调 用函数都用入 / 出 栈 来 备 拷 贝 参数 .

 

 

 

标题： ：形参与 实 参概念

说 到形参与 实 参，在 C++ 出来之前其 实 很 简单 ，就一句 话 ：形参的改 变 不影响 实 参。 这 个状 态 直到 C++ 有了 “ 引用 传递 ” 才有改 变 。
　　要弄清 这 个，首先得弄清形参与 实 参是什 么东 西。因 为 函数是一段 “ 可以重用而不必重写 ” 的代 码 ， 每 次重用当然未必完全相同（不可否 认 有些函数 每 次重用都完全相同），那 么 不同在哪里呢？又怎 样产 生不同呢？一 种 方法是依靠随机，随机是个好 东 西，不要 说 客 户 了， 连 程序 员 都无法控制 每 次 调 用的 结 果。第二 种 方法是凭客 观 条件（比如运行 时间 、机器配置）。但是 这 些函数 应 用很窄， 类 似于 “y=Sin(x)” 这样 的函 数就 绝 不能 这样 做。
　　那 么 ，从 “y=sin(x)” 的形式看来，能决定函数怎 样 运行的唯一因素就是 x 的 值 了。函数的某次运行是受某一个 x 值 的影响并控制的，而下一次运行， 则 会受另一个 x 值 的影响。那 么 ， 调 用函数者就有必要告 诉 函数：我要用哪个 值 来控制你，而函数自己 则 有必要保存 这 个 值 ，直到函数 结 束。
　　 为 此，在函数内部建立一个 临时 的、局部的 变 量， 该变 量的作用域就是函数内部， 该变 量的作用 时间 就是从函数 开 始 执 行到 结 束 执 行。如果同一函数在同一 时间 有几个副本在 执 行（ 这种 情况在多 线 程程序中会出 现 ），那 么 它 们 是互不相干的，它 们 内 部的 变 量也是互不相干的。 这 个 变 量就叫做 “ 形参 ” ，全称形式参数。
　　 “ 形式 ” 是跟 “ 实际 ” 相 对 的，另一个参数就是 实际 参数，叫 “ 实 参 ” ，在 调 用函数 时 ， 这 个 值 将决定函数内部的形参的 值 。 实 参在函数中是否可 见 ？ 这 要取决于两个因素：一是 实 参的作用域，二是有没有被形参覆盖。先 说 第一个因素，如果只 谈 C 语 言，那 么 所 谓 的作用域就是全局与局部两 种 ，但是 C++ 中 还 有 “ 类 作用域 ” 这 一概念，由此第一个因素 变 得 复杂 了。第二个因素本身并不 复杂 ，但是如果没有引起程序 员 的注意，那 么 造成的 问题 是很 难发现 的。 试 看下以下程序：
int a;// 全局 变 量
int ttt(int a)// 该 函数的形参也叫 a
{
　　 cout << ++a << endl;
　　 return a;
}
int main()
{
　　 a = 3;
　　 cout << a << endl;
　　 cout<< ttt(a) << endl;
　　 cout << a << endl;
　　 return 0;
}
　　 该 程序中有一个全局的 a 变 量，但是在 ttt() 函数中却被另一个 a 覆盖了，所以， ++a 没有影响到全局的 a ，如果把函数定 义 改 为 “int ttt(int b)” 则 有不同的 结 果 。
　　以上把 “ 形参 ” 和 “ 实 参 ” 提了 这么 多，主要目的 还 是 讲 清 “ 形参的改 变 不影响 实 参 ” 这 句 话 。字数不少了，留到下篇文章再 续 吧。（我 觉 得我写得不像 读书 笔 记 ，倒像是教材了。 呵呵 ）

 

标题： ：函数的定 义

不 记 得在哪本 书 上看到 过 ，函数的定 义为 “ 有名称的一段代 码 ” 。 这 大概地 说 明了函数的 实质 ：首先、它是一段代 码 ，其次、 这 段代 码 可以被重 复 使用而不必重 复编 写，第三、它是有名字的，在需要重用的 时 候凭名字来 调 用。
　　 这 个 说 法到了 C++ 中 变 得 复杂 了。原因之一是 C++ 支持函数重 载 ，也就是 说 出 现 了同名函数。 虽 然 编译 器在 编译时产 生不同的函数名，但那必竟是 编译 器的事， 对 于程序 员 来 说 就是同一个函数名。原因之二是 C++ 支持运算符重 载 ，可以用一个 类 似于 “+” 号的运算符来 调 用函数。运算符重 载 明 摆 着是 为 了配合 类对 象的运算，因 为 如果没有 类 ， 仅针对 内置 类 型，运算符是没必要重 载 的。 —— 我 试验 了一下，自定 义 了一个 “int operator +(int i, int j)” 函数， 结 果没有通 过编译 。
　　于是，到了 C++ 中，函数的概念被修改 为 “ 函数由函数名以及一 组 操作数 类 型唯一地表示 ” ，依我看， 这样说还 不 够 。 严 格 说 来， 应该说 “ 函数由作用域、函数名以及一 组 操作数 类 型唯一地表示 ” ，理由很 简单 ，因 为 在不同的作用域中可以出 现 名称相同、参数 类 型也相同的函数，除非把 “ 作用域 :: 函数名 ” 合起来看作一个函数名。
　　函数 对 函数体没有任何 强 制性要求，哪怕函数体 为 空也可以。不 过 ，无 论 是空、一句 语 名， 还 是多句 语 句，花括号一定不可少。在 这 里，包括在花括号内的若干行 语 句不能再 视为 一个 复 合 语 句了 —— 因 为 能放 复 合 语 句的地方也能放 简单语 句，而 简单语 句可以不使用花括号。
　　不管你如何看待 这组 花括号，有一点是肯定的：花括号内部是一个作用域。那 么 ，内部定 义 的 变 量就只有在内部使用了。 这 就是局部 变 量，在任何函数（包括 main() ）内部定 义 的 变 量都是局部 变 量 —— 初学者可能以 为 在 main() 内部定 义 的 变 量是全局 变 量。
　　有一 种 内部 变 量的定 义 与以往的定 义 方式不一 样 ，那就是函数的参数。不同之 处 在于：一是它 们 用逗号分隔，二是不允 许 用 “int i,j” 这样 的方式定 义 一 组变 量。我想，也 许 正是因 为 所有定 义 用逗号分隔，才造成不允 许 后者的吧， 毕 竟 这样 会 带 来歧 义 ——j 没有指定 类 型。如果用分号来分隔，那 么 后者的 方式也 许 就可以了。 这 是 C++ 标 准的事，我没有能力来 为标 准出 谋 划策，只能妄加猜 测 了。
　　函数的返回 值 也是一个 类 型，与 变 量的 类 型一 样 ，它可以是内置 类 型，也可以是 类类 型， 还 可以是引用和指 针 。
　　引用：在 C++ 标 准化之前，如果缺少 显 式返回 类 型，函数的返回 值 将被假定 为 int 型。
　　笔 记 ：据我 测试 ，在 VC++.NET 中， 这样 做是可以的。照 这么说 ， VC++.NET 仍然没有按照 C++ 标 准做？或者 说 VC++.NET 迁就了老程序 员 ？

对本文本的评论有：

函数的参数当然不能使用类似int i,j的方式,因为调用函数的时候,涉及到的不仅仅是定义参数,还有把要处理的变量入栈,调用的函数运行前的第一件事,是把被入栈的变量出栈.
这与int i,j定义变量做的事完全不同,所以,不按定义变量的方式写,也很正常.
如果偷猫兄一定要写得一样,那就自己做一个编译器吧.

 

标题： ：函数概念

进 入第七章学 习 。
　　 “ 函数 ” 这 个概念在 C/C++ 里 头 是很 烦 人的。原因在于，好多 C 语 言入 门书 的第一章第一 节 都 说 “C 语 言是由函数 组 成的 ” ，初学者学到 这 里，就好像是 刚 推 开 C 的大 门 就被一个麻袋套在 头 上，什 么 也看不 见 了。那些 书 本 还举 了一个例子，然后 对 照着例子 说 “ 这 个程序是由 main() 、 scanf() 、 printf() 函数 组 成的 ……” 。我 晕 啊，初学者第一天上 C 的 课 ，哪里会管什 么 函数不函数的。
　　 这 点 BASIC 做得不 错 ，倒不是 说 BASIC 比 C++ 好，而是 BASIC 容易入 门 。在 开头 几 节课 不必理会 这么复杂 的 东 西，学了 “Let 语 句 ” 、 “Print 语 句 ” 就可以 涉 足 简单 的算法了。然后提到的 “ 函数 ” 是包括数学函数在内的 “ 内部函数 ” 。我 们 在数学里学 过 “ 函数 ” 概念，知道 “y=Sin(x)” 是一个函数， 现 在在 BASIC 里学到一 样 的函数，自然容易入 门 。等 这 一切都熟悉了，再去学 习 自己写的函数 —— 自定 义 函数，会更加理解程序中的 “ 函数 ” 概念。
　　 VB 与早期的 BASIC 相比，使用了 “ 事件 驱动 ” 原理。画完界面就得面 对 函数了 ，但是 VB 用 “ 事件 ” 这 个 说 法来回避了。初学者可以不知道 “Private Sub Command1_Click()” 究竟代表什 么 ，只要知道那是 “ 按 钮 控件被 单击 后 执 行的代 码 ” 就 够 了。等到后来，学 习 了 “ 自定 义 函数 ” 后，必然会恍然大悟。
　　回到 C++ 中，学 习 之初用到的函数的确是 现 成的 库 函数，但是正因 为过 早地提到了函数概念， 导 致了初学者无所适从。有没有 别 的 办 法呢？当然有了，至少《 C++ Primer 》 这 本 书 一直到第七章才 开 始提 “ 函数 ” 二字。
　　另外： VB 中有 “ 函数 ” 和 “ 子程序 ” 两个不同的概念，如今 “ 子程序 ” 又叫 “ 过 程 ” ，除了使用不同的 关键 字以外，它 们 的惟一区 别 是有没有返回 值 。 C 将它 们 合并了，都叫函数。其 实 ， VB 里的函数也可以 丢 弃返回 值 ，只是 VB 里没有与 “void” 对应 的 词 ，无法定 义 不返 值 的函数，才不得已出此下策 。

 

 

标题： ： try 、 catch 和 assert

程序 员 是要慢慢成 长 的，比如 错误处 理 这种 事情，就不是一 开 始就面 对 的。当我 们编 的程序 还 很小，小到 “cin>>i; cout<<i;” 这样 的程度， 错误处 理不是我 们 要学 习 的目 标 。但是，一旦 开 始 编 写 实 用的程序，那 么 ，无 论 考 虑 多 么 周到，无 论 代 码 多 么 精良。意外 总 是 难 免的。 这 些意外可能来自程序 员 的 设计 不到位、可能来自用 户 的 错误 操作、 还 可能来自机器与网 络 的不确定因素。
　　没有什 么 比追踪 错误 更 难过 的事了， 记 得有一回我在追踪一个 VB 程序的 错误 。 经过长时间测试 ，我 发现 程序在运行中突然 发 生很大的跳 跃 ：函数 A 调 用 B ， B 调 用 C ，在 C 的 执 行 过 程中，居然会突然跳到 A 中。后来追 查发现 ，原来 A 中有一行 “On Error Goto” 语 句。 这 一个 语 句，影响了我 调试 C 函数。从那以后，我明白了，除非程序要 发 布了，否 则别 启 动错误处 理。
　　 C++ 与 VB 不一 样 ， VB 用一句 “On Error Goto” 启 动 了 错误处 理后，在 该 函数 结 束之前一直有效（除非 显 式地 关闭 它）。如果 发 生了异常， 处 理代 码 要根据异常的 值 来分析异常的 类 型。而 C++ 可以 选择 可能出 现 异常的内容放 进 try 后的 块 中。一个函数内部可以有多个 try 块 ，而 每 个 try 块 又可以附 带 多个 catch 来 处 理。 应该说 ， C++ 中的异常 处 理更灵活，当然也更容易出 错 。我前 阵 子 发 生的 错误 就是在 ADO 处 理后只有 “catch(_com_error *e)” ，但是 实际 上出 现 的异常却不是 “_com_error” 类 的， 结 果仍然抓不往异常。
　　异常 处 理和 assert 之 间 的 关 系有些 让 人 难 以捉摸。一方面它 们 各有各的作用，另一方面它 们 有 时 会互相影响。我就曾 经 在 这 上面吃 过亏 ：我的程序是在服 务 器上运行的，从来没人会 盯 着服 务 器看，所以我的程序不允 许弹 出 对话 框。我写了比 较 完善的异常 处 理，无 论 出 现 什 么错误 ，都 记录进 LOG 文件，然后 继续 运行。但是我却 是用 DEBUG 模式 编译 的， 结 果异常到来 时 ， try 没起作用，倒是 assert 起作用了， 弹 了个 对话 框在那儿。 这 件事 给 我的启 发 是： 别 以 为 自己是程序的客 户 就可以用 DEBUG 模式 编译 。

对本文本的评论有：

错误捕捉是很烦人,我的感觉是能在try代码段外解决的错误,就尽量在外头自己解决,尽量少依靠try来处理捕获错误.
在网络编程中,有些错误是无法预知的,比如网络连接断了,数据库当了...好象在这些情况下,用try比较好.
我有一次写的一个服务程序,用户用了一段时间后,经常会异常中止,查来查去查不出原因,后来才发现是ORACLE的日志满了,这个错误显然我在写程序的时候没有想过,丢脸啊...

 

标题： ： break 、 continue 和 goto

break 和 continue 的使用范 围 比 较 一致，两都可以用于循 环 ，其中 break 还 可以用于 switch 。功能上也有一定的相似性， break 就相当于退学， continue 则 相当于跳 级 。 对 于 break ，程序究竟跳到哪儿比 较 好理解。 但是 continue 究竟跳到哪儿去了，初学者可能有些疑惑，不妨就当它跳到了循 环 体最后一句 语 句的后面。
　　如果它 们处 在由多重循 环 和 switch 组 成的圈圈里，那 么 它 们 就 对 包括它 们 的最里 层 起作用。于是， 设 想一下子跳出多重循 环 的人可能忘不了 goto 。
　　引用：从上世 纪 60 年代后期 开 始，不主 张 使用 goto 语 句。 …… 所有使用 goto 的程序都可以改写成不用 goto 。
　　笔 记 ： goto 是一个很有争 议 的 语 句， 语 多 书 本建 议 少用或不用它，我个人的 习惯 是 坚 决不用。不 过 ，至于 “ 上世 纪 60 年代 ” 这 个 说 法，我倒是一直不知道。因 为 我自己学 习 BASIC 已 经 是 1994 年，那 时 候学的是 带 行号的 GW-BASIC ， goto 是必 须 用到的 语 句。莫非当 时 我 们 学校 开设 的 课 程居然是落后二十年的内容？
　　林 锐 博士 对 goto 另有看法，他 说 ： “ 错误 是 程序 员 自己造成的，不是 goto 的 过错 。 goto 至少有一 处 可 显 神通，它能从多重循 环 中咻地一下子跳到外面， …… 就像房子着火了，来不及从楼梯一 级 一 级 往下走，可从窗口跳出火坑。 ……” （《高 质 量 C++/C 编 程指南》第 32 页 ）
　　我写的程序目前 还 没有超越三 级 循 环 。从最里 层 往外跳，如果跳一 层 ，就 break ，如果跳两 层 或三 层 ，一是 这种 可能性很小，二是如果真的碰到了，我就用其它条件来控制外 层 循 环 是否 继续 break ，自从 1997 年 进 入 结 构化的程序 设计 以来，我的确完全抛弃了 goto 。 ——VB 中的 “On Error Goto” 除外，出 现错误 ，自然不管在哪一 层 ，都 给 我跳 进错误处 理中。
　　 goto 的目 标 是一个 标 号， 这 个 标 号的起名倒有点意思，因 为标 号只用于 goto ，所以它的名字可以与任何 变 量名以及其它 标识 符一 样 而不 产 生重名。以前的程序是 带 行号的，所以就 “goto  行号 ” ， 现 在程序不 带 行号了，但是允 许 在任何地方加 标 号。 编译 器在碰到它 们 的 时 候，大概就是凭其后 头 的冒号来判断 这 个名字不需要 检验 合法性。那 么 ， C++ 中已有的 “public:” 算不算 标 号呢？
　　 为 此，我做了个 实验 ： 实验 内容一是我在 类 的声明里加入了一行 “pub:” ，二是我在程序段中加入了一行 “public:” 。 结 果 发现 两都都不能通 过编译 。也就是 说 ， 实验 一 说 明在 类 定 义这样 的地方不允 许 使用 标 号（也用不着，因 为 它不在任何函数内部， goto 是运行 时 的事，与 编译 无 关 ，而且 goto 不允 许 跨函数跳越。）， 实验 二 说 明在程序段中的 标 号不允 许 使用保留字 。

对本文本的评论有：

不主张使用GOTO语句是为了让程序看起来顺眼而己.看:模块化的代码.其实的确没什么大不了的.记住,当你的程序被编译成机器代码以后,里面的跳转全是JMP,相当于GOTO.

 

自从和草莓对骂以来，你就学会了狡辩。
我有跟你讨论机器码吗？
程序设计的风格是为了程序维护，
不是为了编译。

 

标题： ： while 、 for 语 句

while 中有一个怪事： 类 似于 “while (int i = GetInt())” 这样 的 语 句，在条件中定 义 一个 变 量，在 for 中非常常 见 ，也很好理解。但是用在 while 中却有所不同，如果用在 while 中，那 么每 次循 环 都会 经历 一次 创 建和撤 销 的 过 程。 —— 天， 还 是不要 这样 写吧。幸 亏 我 总 是在 while 前面定 义 并初始化 变 量的。
　　 do-while 与 while 有着不一般的 关 系，所以几乎所有的 书 本都是把它 们 放一起 讲 的。当年学 BASIC 时 ，花了不少的功夫去学 习 “ 当型循 环 ” 和 “ 直到型循 环 ” 。的确，当型和直到型都有存在的必要，因 为 程序的确有 这 两 种逻辑 需要。于是 C 、 BASIC 以及 PASCAL 等程序 语 言都提供了 这 两 种 循 环 。不 过 提供 归 提供，怎 么 用却是程序 员 自己的事。就我个人而言，我 还 是喜 欢 用当型循 环 。因 为 当型循 环 可以模 拟 出直到型循 环 的效果来。比如以下四段代 码 ，它 们 是完全一致的：
// 代 码 1
do
{
　　循 环 体 ;
　　 BoolVal =  表达式 ;
}while (BoolVal);
// 代 码 2
BoolVal = 1;// 先 赋 True 值
while(BoolVal)
{
　　循 环 体 ;
　　 BoolVal =  表达式 ;
}
// 代 码 3
do
{
　　循 环 体 ;
}while ( 表达式 )
// 代 码 4
while(1)
{
　　循 环 体 ;
　　 if (! 表达式 ) break;
}
　　 for 语 句的 执 行 顺 序和 执 行 逻辑 是最 难讲 清的了。如果知道了，就是 这么 回事。如果不知道，不 费 上半天口舌是 说 不清的。原因在于 for 包括四个互相 关联 的 语 句，其中三个在 “for” 后面的括号里，另一个作 为 循 环 体存在。 这 也 难 怪 BASIC 要将 for 语 句定 义为 “For i=M To N Step t” 的格式。
　　 for 括号里的三个 语 句是可以省略的，最牛 B 的省略莫 过 于 “for (;;)” 了。会 这样 写的人，要 么 是 彻彻 底底地明白了 for 的 逻辑 的人，要 么 是一点不懂的人。我 觉 得，如果要我 这样 写，我不如写 “while(1)” 了。

 

 

标题： ： if 、 switch 语 句

本 书 不愧 为经 典 书 ，在 if 这 地方能避免 说 教， 讲 得 绘 声 绘 色，真叫人佩服。
　　大体上 if 要注意的就只有 else 的配 对问题 了。如果在 else 前方有多个没有配 对 的 if ，那就找最近的一个配 对 。如果要改 变这种 默 认 的 “ 拉郎配 ” ，就加上花括号。
　　 还 是引用林 锐 博士的一句 话 吧： “if 、 for 、 while 、 do 等 …… 不 论执 行 语 句有多少都要加 {} 。 这样 可以防止 书 写失 误 。 ” （《高 质 量 C++/C 编 程指南》第 16 页 ）
　　 if 语 句曾有一个令我疑惑 了好久的 东 西： “else if” 究竟算什 么 ？因 为 BASIC 里有 “ElseIf” 这 个 关键词 ，而 C++ 中所 谓 的 “else if” 是两个 关 健 词组 成的。中 间 插了个空格。我 们 都知道， C++ 的 语 句与 语 句之 间 插入若干个（包括 0 个）空格、 TAB 、回 车 都是一 样 的，那 么 ，如果我把 else 后插入一个回 车 ，不成了另一 种结 构的 if 语 句了 么 ？后来我仔 细 地分析一下 逻辑关 系，才豁然 开 朗：原来是 BASIC 的 “ElseIf” 干 扰 了我的理解。 C++ 中用哪 种 方法去理解都没区 别 。
　　都 说 switch 是 为 了 简 化 if 而出 现 的，但是 switch 虽 然可以 简 化 if ，却并不是任何 时 候都能使用。使用 switch 有两个先决因素：一是所有的条件都必 须 是 编译时 常量。也就是 说 如果要在程序运行 时 再决定 case 后的条件，那是不行的。另一个因素是只能拿出若干个整数 值 来比 较 是否相等，既不能是浮点数，也不能比 较 大于或小于。
　　 switch 最容易出 错 的就是 丢 失 break 语 句了。因 为 按常 规 思路，人 们总 以 为 两个 标 号之 间 的 语 句才是 应该执 行的。从 BASIC 过 来的人更加痛苦，因 为 BASIC 里不需要 类 似于 break 这样 的 语 句来表示 结 束。
　　我的做法是，在打程序框架 时 ，先把 case 标 号和 break 写了，其余的再去完善。即使 逻辑 上不需要 break 语 句，也要写上 “//break;” ， 这样 可以提醒自己和 团队 的伙伴：此 处 并未 丢 失 break ，而是的确不需要。
　　 丢 失 default 是最理直气壮的了。因 为 的确有 许 多 时 候并不需要 default ，但是我的 经验 是要加上 default 以及它后面的 break ，原因同上，提醒自己和伙伴我没有 遗 漏 。

 

标题： ： 简单语 句与 复 合 语 句

祝 贺进 入第 6 章的学 习 。
　　 简单语 句就是只有一句的 语 句， “ 复 合 语 句 ” 也叫 语 句 块 ，是由多句 语 句 组 成的一个整体。 虽 然 BASIC 也有 语 句 块 的概念，但是它 们 却是不同的概念： BASIC 将 简单语 句 视为 特殊的 语 句 块 ，而 C++ 则 将 语 句 块视为 特殊的 简单语 句。个人 认为 ， C++ 中 复 合 语 句的存在是 为 了 补 充 C++ 没有 “end if” 之 类语 句的缺陷。
　　 BASIC 中， if 有 end if （行 if 除外）、 while 有 wend ， do 有 loop 。也就是 说 ，有 头 就有尾，所以， BASIC 编译 器不担心无法确定 语 句 块 的大小。 C++ 则 不同，它的 这 些 关键 字都没有 结 束 语 句。没有 结 束 标记 ， 谁 知道它的主体究竟是几行呢？所以， C++ 只好 规 定：所有 这 些 结 构的 语 句体都只能包含一句，而且必 须 包含一句（有且 仅 有一句）。 换 句 话说 ，如果要多句，你也得做成一句的 样 。
　　将多行做成一行，就是所 谓 的 “ 复 合 语 句 ” 了。
　　 说 到 简单语 句，空 语 句和空 块 是不能不提的。空 语 句（ 块 ）也是 语 句（ 块 ），只是它 啥 也不干。空 语 句存在的原因，无非也是因 为 C++ 中 规 定了 语 句体必 须 是一句。 刚 才 说 了，那些 结 构的 语 句体是 “ 有且 仅 有一句 ” ，不 仅仅 “ 多于一句要写成一句的 样 ” ，反 过 来 说 ，如果没有任何内容，你 也得 伪 造一句出来。于是 “ 空 语 句 ” 问 世了。
　　以下 语 句就是一个典型的例子：
int s = 0;
for (int i=1,s=0; i<101; s+=i,++i) ;// 空 语 句
　　空 语 句的存在 为 C++ 徒增了 难 度与危 险 性，很多初学者弄不清哪些 语 句要以分号 结 尾，哪些 语 句不要， 错误 地在 for() 后面加了个分号， 结 果使循 环 体被取消了循 环 的 资 格，而且有可能出 现 死循 环 。

 

 

标题： ： 显 式 转换

引用： 显 式 转换 也称 为强 制 类 型 转换 。
　　笔 记 ：我 觉 得要提 强 制 类 型 转换 ，得从 C 风 格的 说 起。 这 里面可能有我个人的原因。因 为 我个人 习惯 了 C 风 格的 强 制 类 型 转换 。
　　在 C 语 言中， 强 制 类 型 转换 就是用借助一 对 括号同 时 把 类 型名和表达式列出来，比如 “(int)t” 和 “int(t)” 就是把 t 转为 int 型。
　　引用：因 为 要覆盖通常的 标 准 转换 ，所以需 显 式使用 强 制 类 型 转换 。 …… 显 式使用 强 制 类 型 转换 的另一个原因是：可能存在多 种转换时 ，需要 选择 一 种 特定的 类 型 转换 。
　　笔 记 ：从外文 图书 翻 译过 来的中国 图书 有个通病，就是 语 言不 伦 不 类 。本 书 算是翻 译 得非常好的了，依然无法 摆 脱 这种 影响。上文的意思无非是 说 ：我不希望使用默 认 的 转换规则 的 时 候，就可以 显 式地 规 定按我的要求 转换 。如果要 举 个例子，可以拿上文《 类 型 转换 之 隐 式 转换 》中一个 现 成的例子：
int a = -3;
unsigned b = 3;
if (a == b)// 隐 式 转换 将 转为 unsigned int
if (a == (int)b)// 显 式指定 转换为 int
　　 这种 用法更多地用于指 针类 型的 转换 。因 为 指 针类 型就是指 针 所指向 对 象的 类 型，而指 针 本身是没有 类 型区 别 的。所以，指向任何 类 型的指 针 可以互相 转换 。最典型的就是 void* 和其它 类 型之 间 的互 换 了，比如： “int* p = (int*)malloc(sizeof(int) * MaxSize);”
　　 还 有一 种 用法就是在 编译 器不允 许进 行 隐 式 转换 的 时 候，比如将 const 对 象 转为 非 const 对 象。如：
const int t = 3;
int* p = (int*)&t;// 本来要写作 const int* p = &t;
　　 这种 用法 还 是少用 为 好，理由很 简单 ， 编译 器之所以不允 许进 行 转换 ，就是 为 了保 护 数据，你非要破坏 这种 安全性自然不好。即使能确信 这样 做不 产 生 恶 果， 这样 做至少是没有良好 风 格的。
　　 C++ 中 为显 式 类 型 转换 提供了四 种 不同的操作符： static_case 、 dynamic_cast 、 const_cast 、 reinterpret_cast 。个人 认为 与 C 风 格的相比似乎都没有什 么进步 。
　　引用： 强 制 类 型 转换关闭 或挂起了正常的 类 型 检查 。 强 烈建 议 程序 员 避免使用 强 制 类 型 转换 ，不依 赖强 制 类 型 转换 也能写好很好的 C++ 程序。

 

 

标题： ： 类对 象的 隐 式 转换

与算 术类 型相比， 类 的 转换 更 复杂 。因 为 算 术转换 只 涉 及到精度的 问题 ，而 类对 象的 转换 却 涉 及到能否 转换 以及怎 样转换 的 问题 。
　　 隐 式 转换 就是 隐 式 转换 ，它会出 现 在你没有注意的地方。参看以下代 码 ：
class CMyInt
{
public:
　　 CMyInt();
　　 CMyInt(int i);
　　 ~CMyInt();
private:
　　 int m_i;
};
CMyInt::CMyInt()
{
　　 m_i = 0;
　　 cout << " 无参数构造 ( 默 认 0)" << endl;
}
CMyInt::CMyInt(int i)
{
　　 m_i = i;
　　 cout << " 从整数构造 , 值为 " << i << endl;
}
CMyInt::~CMyInt()
{
　　 cout << " 析构 " << m_i << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
　　 CMyInt a;
　　 a = 3;
　　 return 0;
}
　　 执 行以上代 码 会 发现 ，程序中有两次构造与两次析构，原因是 “a = 3;” 这 个 赋值 表达式要将右 边 的 类 型 转换为 左 边 的 类 型。 而 这 个 转换 是通 过调 用构造函数来 进 行的。
　　不 过 ，以上代 码 只是 测试 用的， 读 者 们 千万不要在 实际 工作中写 这样 的代 码 。因 为这样 做是很不科学的。 “a = 3;” 这样 的表达式，只要 CMyInt 类 提供了右 值类 型 为 int 的 赋值 操作符重 载 ，就可以避免使用构造函数来 进 行 转换 。操作符重 载 代 码 如下：
　　在 类 定 义 的 public 段添加一行： “CMyInt& operator = (const int i);” 然后在 类 定 义 外部添加以下代 码 ：
CMyInt& CMyInt::operator = (const int i)
{
　　 m_i = i;
　　 cout << "operator =" << i << endl;
　　 return *this;
}
　　加了以上代 码 ，同 样 是 “a = 3;” 就不使用 类 型 转换 了，改 为 使用 赋值 操作。我写下以上 这 段程序的目的只是 验证 VC++ 中会有 类对 象的 转换 ，它 们 与算 术类 型的 转换 差不多：生成一个合适的 临时对 象，参与运算以后再把 临时对 象 释 放掉 。