C++ Primer读书笔记

 

C++ Primer读书笔记

注：本文转自www.Eachfun.com

         （整理说明：本资料是我在网上无意间找到的，读起来感觉不错，但由于原文是每章一个网页的格式，读起来不是很习惯，而且也不方便保存，所以我花了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++中会有类对象的转换，它们与算术类型的转换差不多：生成一个合适的临时对象，参与运算以后再把临时对象释放掉。

标题：：类型转换之隐式转换

对于我们来说，3+1.5=4.5。但是对于计算机来说，这两个数的相加可不这么简单。因为3与3.0是不同的数据类型，3.0与1.5是可以相加的，3却不能与1.5相加。于是，C++在对上面的表达式进行处理时，有必要对其中一个（或两者）进行转换。
　　因为这个转换是“隐式”的，也就是说这个转换不让程序员知道，那么，系统就不能必须保证不产生损失，这个损失指的是精度。为了不损失精度，数据总是向精度高的类型转换。惟一的例外是当某个变量用作条件时，它被转换为bool型。
　　对算术类型的转换是这样的：所有比int小的都转为int或unsigned int，即使没有必要也这么转。原因很简单，因为int的长度正好等于字长。对CPU来说，一次处理一个字是最快的。如果int或unsigned int无法达到要求，则往long、double转化。
　　如果每一个转换都能不造成损失，那自然是好事。可是世间的事总有不随人愿的时候。对于同一种算术类型，其signed和unsigned所能表达的范围是一样大，但却是互不重叠的两个范围。就像“妇联”和“工会”一样，往哪边转换都可能会产生损失。这是无法解决的问题，所以，在VC中，试图比较int和unsigned int变量时会显示警告。
　　奇怪的是，据我测试，在VC++.net中，只有进行“<”和“>”比较的时候才会显示警告，而进行“==”和“!=”比较的时候却不显示警告。实际上这两个比较也会有同样的问题产生，比如以下代码：
int a = -3;
unsigned b = 4294967293;
if (a == b) cout << "yes" << endl;
　　测试运行以上代码会发现表达式a==b的值为true。这是从int转为unsigned int过程中的副作用，这个副作用我们应该知道，但是VC++.net不进行任何警告似乎也有些与理不通。——难道我关闭了某些警告？
　　其它隐式转换还包括数组名转换为指针、算术值用作条件时转换为bool，枚举被转换为整数，非const对象转换为const对象等。其中枚举转换为整数没什么要提的，枚举值本来就是整数的别名，非const对象转为const对象只是临时声明它的保护级别，通常用于作为参数传递时。

 

 

标题：：内存管理之new和delete

林锐博士曾将内存管理比喻为“雷区”（《高质量C++/C编程指南》第44页），内存管理这块难不难？恐怕不好说。“会者不难难者不会”嘛。但是说内存管理这块难以成为“会者”，应该是没有错的。
　　程序时时刻刻与内存打交道，只不过以往我们不用考虑，甚至不用知道。所以，所谓“内存管理”，是特指堆内存。
　　如果把堆内存和栈内存的使用放在一起考虑，可以降低对内存管理恐惧。
　　一、内存的分配：
　　int i(100);//栈上分配内存
　　int *pi = new int(100);//堆上分配内存
　　以上两种分配，都使用了100作为初始值进行初始化，如果是进行类对象的分配，它们还可以指定使用哪个构造函数，比如：
　　CString s(s1);//栈上分配内存
　　CString *ps = new CString(s1)//堆上分配内存
　　这里的s可以是char*指针，也可以是另一个CString对象，它的类型将决定上面这两行语句调用哪一个构造函数。
　　在这里，有一点要特别说明，如果要使用默认构造函数，则new语句后面可以用空括号对，而栈内分配的语句切不可用空括号对。如果写成“CString s();”，则并不是定义一个CString对象s，而是定义一个返回值为CString的函数s。
　　上面两种分配，也都可以分配对象数组，不同的是，用new操作符在堆内存分配数组时，只能调用默认构造函数。而在栈上分配却可以指定对象成员的初始值。如：
　　int a[3] = {1,2,3};//栈上分配内存，int可以换成其它类型名，后面的初始值可作相应调整。
　　int *p = new int[3];//不能指定这三个对象的初始值
　　二、内存的访问：
　　栈内存可以通过对象访问，也可以通过指针访问，堆内存通过指针访问。方法完全相同。
　　三、内存的释放：
　　栈内存在对象作用域结束后自动释放，堆内存要用delete。
　　delete pi;//释放内存
　　delete []p;//释放对象数组
　　对于释放对象数组，那个空的[]对不可以丢，否则将只释放数组的第一个元素。导致内存泄露。
　　有了以上对比，堆内存似乎没有了任何难度。那么内存管理的玄机究竟在哪儿呢？在进行内存分配与释放的时候，有几个注意点要记住：
　　1、new操作有可能失败，当系统无法分配需要的内存块时，将返回NULL值，所以在new操作之后，要立即判断pi的值是否为NULL。
　　int *pi = new int(100);
　　if (pi = NULL) {...}
　　2、堆上分配的内存必须delete，而且只可以delete一次。为了保证内存只被delete一次，请务必记住delete以后立即将指针设为NULL：
　　delete pi;
　　pi = NULL;
　　虽然“pi=NULL;”不是必须的，但这是个好习惯。将指针设为NULL既可以防止继续读写该内存，也可以防止再次释放该内存。
　　老的C程序员可能忘不了malloc和free函数，它们也可以进行内存的分配与释放。但是C++时代它们已经落伍了。它们只是按请求的字节数进行分配，而不管你用这块内存来干什么。这样做，就等于放弃了类对象的构造与析构。对于很多类来说，这样做是很危险的。

 

 

标题：：优先级、结合性和求值顺序

说到优先级，我能熟练背出“先乘除，后加减”，之于C++列出的整整19个优先级，每个优先级又包含若干个操作符，我总是看了就头皮发麻。以我的记性，连军旗里哪个大哪个小都背不出来，这几十个操作符——还是饶了我吧。
　　记住林锐博士的话：“如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。”（《高质量C++/C编程指南》第26页）这样做最直接的作用是不用记忆了复杂的优先级了，不用记忆并不是因为懒，而是为了更清晰。毕竟程序不只是编给计算机运行的，当我们处在一个多人协作的团体中时，程序的清晰度和精确性比性能要高得多。再说，多加几对括号是不影响运行效率的。
　　结合性和求值顺序是容易混淆的两个概念。每一个操作符都规定了结合性，但是只有极少数操作符规定求值顺序。结合性是说如果有多个同级别的操作符，这些操作数该如何分组。比如“1+2+3”究竟分成“(1+2)+3”还是“1+(2+3)”，虽然这两种分组最终没有区别，但不等于所有操作符都不产生区别。即使不产生区别，计算机毕竟是计算机，它只能按死的规范做事，于其给它灵活机制，还不如规定了结合性让它遵守。
　　C++只有四个操作符规定了求值顺序，它们是“&&”、“||”、“?:”和“,”，记住这四个操作符并不难。反过来记住其它操作符也不难，难的是在写程序中是否有这个意识。那么多网友讨论“j = i++ + i++ + i++;”的结果，正说明了还有好多人不了解“未定义”的威力。如果不小心使用了依赖于未定义求值程序的语句，将是一个不容易发现并改正的问题。比如“if (a[index++] < a[index]);”

 

 

标题：：sizeof和逗号操作符

把sizeof说成操作符可能有些不合习惯，因为sizeof的用法与函数没区别。但是sizeof与函数有着本质的区别：它是编译时常量。也就是说，在程序编译时，就会求出它的值，并且成为程序中的常量。
　　sizeof本身比较简单，惟一要提的就是它对数组名和指针进行操作的结果。
int a[10];
sizeof(a);
　　该操作返回的是数组所有元素在内存中的总长度。但是如果对指针进行操作，返回的则是指针本身的长度，与指针所指类型无关。
　　正因为数组名与指针有着千丝万缕的关系，所以有时候这个特性会让人摸不着头脑：
int function(int a[10])
{
  sizeof(a);
  ...
}
　　以上sizeof返回的不是数组所有成员的大小，而是指针的大小，因为数组在参数传递中弱化为指针。
　　逗号操作符除了在for语句中应用以外，我没发现在哪儿还有用处。因为在一般情况下，逗号改成分号肯定是可以的，在for语句中因为分号的作用另有定义，所以不能随便改。这才有了逗号的用武之地。

 

 

标题：：条件操作符

我觉得条件操作符的存在就是为了简化if-else语句。第一，它与if-else语句的功能完全一致；第二，它虽然是一行语句，但是它规定了求解顺序，这个顺序保证了有些表达式不被求值。
　　条件操作符是有一定的危险性的，危险的原因在于它的优先级特别底，还容易漏掉括号。它的优先级仅仅高于赋值和逗号运算符，也就是说，只有在与赋值或逗号共存时，才可以免去括号，其它情况下都得加上括号。漏加括号的BUG是很难发现的。
　　比如“cout << (i < j) ? i : j;”这句的实际作用是将表达式“(i<j)”的值输出，然后测试一下cout的状态（<<操作符的返回值是cout），整个表达式的值不管是i还是j，都被丢弃。

 

 

标题：：箭头操作符（->）

箭头操作符是C++发明的全新操作符，但却不是C++才用到的功能。早期的C语言虽然没有类，却有结构体，也允许有指向结构体对象的指针。不同的只是没有发明“->”这个符号来进行简化操作。说到底，“->”的出现只是代替原来就可以实现的功能。
　　引用：C++语言为包含点操作符和解引用操作符的表达式提供了一个同义词：箭头操作符（->）。
　　笔记：这一同义词的出现，不仅仅使程序简化而且更易于理解，更重要的是，它降低了出错的可能性。出什么错呢？这就跟操作符的优先级有关了：
p->a();
(*p).a();
　　以上两行等价，但是第二行却很容易写成“*p.a();”，由于点操作符的优先级高，就成了“*(p.a());”，这里至少包含了两个错误：一是p不是对象，点操作无效；二是试图对类成员解引用（只有当该成员返回指针才有效）。
　　也许有人要说了，第一个错误已经导致了编译不通过，还要说第二个错误干什么？这样理解就错了。VC++为程序员提供了一个十分强大的库，其中有些类的对象，既可以进行点操作也可以进行解引用操作的，如果上例中的p是那种类的对象，而且p.a()刚好又返回指针，那么上面这句将可以通过编译，最终换来难以查找的BUG。
　　记住，尽量多用箭头操作符。

 

 

标题：：++的陷阱

自增和自减符作符是如此常用，以至于没有必要提了。但是任何一本书都会下重手来提它，原因是它虽然简单，却含有玄机。
　　讲到前自增和后自增时，几乎所有的书都是这样讲的：用“j = i++”和“j = ++i”对比，告诉读者虽然i都增了1，但是j却不一样。
　　这也没办法，因为绝大多数书在讲到++时还没有提到“表达式的值”这个概念，有些书本可能从头到尾都不提。对于“j = i++;”来说，它是一个表达式没错，但是等号右侧也是一个表达式，对于表达式“i++”来说，它是有值的，该表达式的值赋予了j，而整个表达式也有一个值，只是这个值被丢弃了。类推：“i = j = k = 1;”语句中单独的“1”就是一个表达式，叫常量表达式，它的值就是1，它给了k，“k=1”这个表达式也有值，它的值就是k的值，它给了j，……最后给i赋值的表达式也有值，它的值就是i的值，这个值被丢弃。
　　弄明白了“表达式的值”后，就可以科学地讲解“++i”和“i++”了，因为这两个表达式的值是这样定义的：前置自增/减表达式的值是修改后的变量值，后置则为修改前的值。
　　那么，在不关心表达式的值的时候——即只是给某变量自增或自减一下——究竟用哪个好呢？当然是前置好，因为前置只要用一个指令进行一下自增自减运算，然后直接返回即可。而后置却要先保存好这个初始值，再自增减，然后再返回以前保存的值。写过操作符重载的程序员应该更能体会这里面的区别。
　　“++i”或“i++”是这样简洁，所以它们比“i = i + 1;”要美得多，所以书上说“简洁就是美”。但是，在美的同时，一个美丽的陷阱正在招手，程序员们必须理解并小心。
　　“if (ia[index++] < ia[index])”这样的表达式是危险的。前文中已经提到了，C++中只有极少的几个操作符是规定了求值顺序的，“<”号没有规定，那么，这两个数要比较大小，系统究竟先求前者还是后者？如果先求前者，那么求后者的时候index是值有没有增一？
　　经常在论坛上看到有人讨论“j = i++ + i++ + i++;”的结果，还有人把自己的实践结果贴出来证实自己的理论。这正是初学者令人悲哀与同情的地方：对于应该好好掌握的知识没有足够的热情，却把一腔热血放在这些无须讨论的话题上，C++初学者要走的路不仅长，而且充满了荆棘。

 

 

标题：：回忆十几年前的编程入门

本来不想为这段写读书笔记，不过突然想起十几年前的一件趣事来，还是记下来吧。
　　1993年的时候，学校开设了“劳技”课，讲的是BASIC语言。对于当时连电脑都没看过一眼的我们来说，学校开设这样的课，真是让我们无比感动。我至今仍然感谢我的母校，在片面追求升学率、大量缩减副课的全局下，我的母校居然开设了音乐、美术、劳技等一系列副之又副的课。这让我至今难忘。而令一方面，我今天能够在程序界打拼，完全是从那时候开始陪养的兴趣。如果我的高中没有开设这门课，我未必就不进入程序界，但是入门至少要晚三年。
　　这三年，我学的编程东西少之又少，对于整个BASIC来说，简直连皮毛都不如，而且学校只提供了一次上机机会，练的是开机与关机。我所谓的“调试程序”是在自己的小霸王学习机上进行的。但是，在电脑没有普及的年份，懂得一点点就是很先进的了。进入大学后，堂堂一个大学的班级，居然只有两个人碰过电脑，大家的基础可想而知。在同学们拼命学习DOS命令的时候，我已经遥遥地走在了前面。之后学习True Basic自然一日千里，之后自学VB、自学C也就顺理成章。如果我的高中没有开设这门课，我未必就不进入程序界，但是我在进大学的头一段时间肯定会与其他同学一起拼命记DOS命令。要知道，其他同学至所以学得比我慢，并不是比我笨，而是没有习惯电脑的思维模式。
　　该说“赋值操作符”了。高中开设的BASIC语言课，其课本是不到半厘米厚的小书。但是我爱不释手地提前阅读了。读得一知半解就去做后面的习题，发现一句“P=P+1”，心想：这怎么可能嘛？P怎么可能等于P加一呢？移项一减，不就相当于0=1了吗？一定是书上印错了。于是，我将其中一个P改成了R，而且是用黑钢笔描的。我描得是如此细致，以至于根本看不出那个R是P改的。等到老师讲到这一节的时候，我虽然已经懂了这里的“=”与数学上的“=”不一样，但是由于把P看成了R，这题还是做错了。
　　当时的情况是这样的：老师喊了几个同学上去做题，没有一个会。老师说“有没有谁会做的？主动上来？”好几个同学立即喊我的名字，把我逼上去了。结果我这么一做就做错了。老师表扬了我的勇气，但是同学却说我虽然平时捧着这本书不放，原来也是个“菜鸟”。
　　赋值操作符就是在那个时候给我留下深刻印像的，那天我知道了，“=”号不表示左右相等。
　　复合赋值操作符也比较简单，理解了它的用法就好了。C++至所以有了赋值操作符以后还要复合赋值操作符，不仅仅是为了简化代码，还可以加快处理速度。“i=i+j”和“i+=j”相比，前者的i求值了两次。不过，这点性能差别对整个程序性能来说不大。还有一个区别就是优先级方面的了。“i*=j+1”如果不写成复合赋值，就要加上括号：i=i*(j+1)。

 

 

标题：：关系、逻辑和位操作符

关系操作符本身没什么好提的，它们与我们平时身边的逻辑一样，所以不难理解。有两点可以略提一下：
　　一、因为ASC字符中没有“≥”这些符号，所以只好用“>=”代替。于是产生了BASIC和C++的两种不同符号集：BASIC用“<>”表示不等于，C++则用“!=”。
　　二、程序设计时不能用“if (i < j < k)”这样的写法。原因很简单，因为这种写法另有含义，或者说正因为不能这样写，才给这种写法另外赋了一种含义。
　　BASIC和C++的逻辑操作符也有完全不同的写法，BASIC用比较直观的关键字“And”、“Or”之类，C++则用“&&”和“||”。这也没什么，记住就行了。
　　逻辑操作符中的“&&”和“||”是C++标准中为数不多的指定了求值顺序的操作符（除此以外还有条件操作符“?:”和逗号操作符“,”，关于求值顺序，后面还将提及）。这样的规定惟一的缺点是需要额外的记忆，优点则是很明显的：它可以让“危险”的操作变得不危险。如“while (i<MaxSize && Array[i]>0)”，对于“Array[i]”来说，指针越界是很可怕的，但是“&&”操作符的求值顺序保证了指针不越界。从另一方面说，要保证指针不越界，就必须记住该操作符的求值顺序（不然就只能分成两个语句写喽）。
　　又要提到bool值的比较了，“if (i < j < k)”的实际就是进行了bool值的比较。本书在讲解的时候，虽然提到了“将k与整数0或1做比较”，但是我宁可提醒大家不去记住这个。记住bool值只有true和false两个值，比记住1和0要好得多，因为虽然false就是0，但是true却不仅是1。
　　C++中如果只有逻辑操作符也就算了，它偏偏还有“&”和“|”这样的位操作符。而位操作正是BASIC不提供的功能。这就给初学C/C++的人带来了难度。难点不在于理解，而在于记忆。位操作符的作用是进行某一Bit位的设定，在一个字节掰成八份用的年代，它非常常用，—比如Turbo C中的屏幕设置，就是3位表示背景色、4位表示前景色、一位表示闪烁，用一个字节完全存放了屏幕字体的信息。现在的海量存储与高速处理中，大可不必这么节约了（从处理速上看，非但没有节约，反而浪费了），所以，不会位操作也没什么大不了的。
　　不过，不熟悉位操作的用户却都知道“<<”和“>>”的另一用处。这事不能怪程序员，几乎所有的C++书本都会从“cin >> i;”和“cout << i;”入手。不用知道这两个操作符原来是干什么的，甚至不用知道“重载”是怎么回事。C++来到这个世界，发展了C语言，使得“知其然不知道其所以然”的程序员也能好好工作。也许这是它的一个进步吧。

 

 

标题：：可爱的算术操作符

算术操作符是最容易理解的符号了，因这它与平时做的数学是完全相同的规则。就连小学的知识“先乘除后加减”都完全适用。
　　不过，就像因为与生活的逻辑完全一样导致易于理解一般，与生活逻辑不一致的问题就比较难以理解了。比如“有9个苹果，3个小朋友分，平均每个小朋友可以分到几个苹果？”，现实中既不可能是-9个苹果，也不可能给-3个小朋友分。而是C/C++中的除法和求余却不得不面对这种情况。它们非但难于理解，而且还有不确定因素。
　　引用：如果两个操作数都为正，除法和求模操作的结果也是正数（或零）；如果两个操作数都是负数，除法操作的结果为正数（或零），而求模操作的结果则为负数（或零）；如果只有一个操作数是负数，这两种操作的结果取决于机器；求模结果的符号也取决于机器，而除法操作的值则是负数（或零）。
　　笔记：以上这一大堆似乎有些费口舌。这么说吧，如果两个数同号，则一切都那么简单。即使是两个负数相除，只要把它们当成两个正数就可以了——商肯定是正的，余数只要对应调整一下符号即可；如果是一正一负两个数相除，那么商肯定是负的，但是究竟是负多少可不一定，余数就更难说了，连是正是负都不能确定。
21 % 6 = 3;
21 % 7 = 0;
-21 % -8 = -5;
21 % -5 = ?;//与机器相关，可能是1可能是-4
21 / 6 = 3;
21 / 3 = 3;
-21 / -28 = 2;
21 / -5 = ?;//与机器相关，可能是-4或-5
　　引用：当只有一个操作数为负数时，求模操作结果值的符号可依据分子（被除数）或分母（除数）的符号而定。如果求模的结果随分子的符号，则除出来的值向零一侧取整；如果求模与分母的符号匹配，则除出来的值向负无穷一侧取整。
　　10个苹果分给-3个朋友，平均每个小朋友可以分到几个？还剩下几个？

 

 

标题：：操作符

第五章开始了，看得出来，从这章才真正开始讲解C++的基本内容。没有这里的内容，前四章都是狗屎。
　　操作符就是我们平时理解的“运算符”了，不过因为C++是计算机语言，它与我们平时生活有着不一样的逻辑，所以，在我们平时看来简单的“3+4”，到了C++里，就得分成一个操作符和两个操作数了。
　　操作符的含义以及它能得到的结果，不仅仅取决于操作符本身，还同时取决于操作数。当初学C语言的时候，发现做除法要用“10/3.0”而不用“10/3”着实惊讶了一回。特别是从BASIC走过来的人，BASIC里没有这么强的类型，所以10/3就是浮点数，要整除还得用“Int()”函数或改用“/”运算符（不是每个VB程序员都知道这个运算符的哦。）
　　从C/C++中弄明白了“10/3.0”和“10/3”，反过来再去理解C与BASIC的区别，不难发现C/C++这样做的确比BASIC高明得多。而进一步了解了硬件的运算机制后，则可以理解这样做不仅仅是高明，而且是必须。
　　引用：有些符号既可以表示一元操作也可以表示二元操作。例如*……，这种两用法相互独立、各不相关，如果将其视为两个不同的符号可能会更容易理解些。……需要根据该符号所处的上下文来确定它代表一元操作还是二元操作。
　　笔记：这是一个大家都明白，但是大家都不会去想的问题。细想起来，我们不去想，正是因为我们早已熟知。然而我们读程序可以上下关联，计算机要做到这点就不容易——比如拼音输入法的自动选词。由此看来，C++编译器是十分优秀的人工智能软件。

 

 

标题：：多维数组

引用：严格地说，C++中没有多维数组。
　　笔记：不只是C++啦，C中就是这样。不过，正因为C++中没有多维数组，而提供了“数组的数组”，所以C/C++在数组使用上更灵活。
　　多维数组的定义和使用没什么要多提的，用过就懂了。无非是多一对括号而已。不过，如果把它跟指针一起用，倒是要注意的：二维数组名对应的是“指向指针的指针”，所以，如果要在函数间传递多维数组，指针类型一定要正确：
　　int a[3][4];
　　int *p1 = &a[0][0];//a[][]是一个int，对其取地址就是int*
　　int *p2 = a[0];//a[0]虽然是a有一个元素，但它也是另一个数组的数组名
　　int **p3 = a;//a是一个二维数组的数组名
　　int **p4 = &a[0];//a[0]是一个数组名，它是a数组的一个成员
　　另外，有一个比较难记、容易混淆的用法：
　　int (*p5)[4] = a;
　　说它容易混淆，是因为它与“int *p5[4];”有着截然不同的意义。前者是指定义一个指向数组的指针，后者则是定义一个指针数组。——头昏ing...
　　本人在实际使用中，经常避开多维数组，而用其它途径来使用一大堆数值。比如可以这样用：
　　int a, b;//两维的元素个数
　　int *p = new int[a*b];
　　for (int i=0; i<a; ++i)
　　　　for (int j=0; j<b; ++j)
　　　　　　p[i*a+j].....;
　　delete []p;
　　用这种方法，就是三维、四维也不用考虑“指向指针的指针”这么复杂的东西。不是我不会，而是不高兴去想。

 

 

标题：：动态数组

我晕，本书才讲了个开头，居然讲到new和delete了。我“偷窥”了一下：下一章开始才讲到操作符，而且下章将有专门的一节讲new和delete。看来这里提到它们的目的只是为了说明string这样的类为什么可以自动适应大小。
　　new的返回值是一个指针，不过本书暂时没有提到new也会返回NULL的。是的，暂时还不用提内容不够这么复杂的情况。
　　引用：在自由存储区中创建的数组对象数组是没有名字的，程序员只能通过其地址间接地访问堆中的对象。
　　笔记：这里有两个问题，一是“数组的名字”其实也是个指针，指针当然也可以看成“数组的名字”，这本来就可以互换的，正如我前面说的一样：“5[a]”完全等价于“*(5+a)”。至于a是静态的数组名还是动态的指针，没有区别。第二个问题是这里提到了“堆”，在没有讲解内存之前，这样说毕竟理解上有难度。还是那句话，这本书是给有一定基础的人看的。
　　令我耳目一新的是：new还能创建const数组。——不是我不懂，而是实在没想到。再说了，创建一大堆const的内容，而且只能初始化为同一个值。那这有什么用？正如本书提到的一样：“这样的数组实际上用处不大”。依我看，不是用处不大，而是根本没用。
　　动态空间的释放应该用“delete []p;”而不是“delete p;”，这是一个只要记住就可以的问题，我之所以提上一句，是因为有人没有注意过这个细节，包括很多自以为很了不起的程序员。
　　引用：如果遗漏了方括号对，这是一个编译器无法发现的错误，将导致程序在运行时出错。

 

 

标题：：C风格字符串

给这篇文章定下这个标题：，是因为书中就是这样说的。本书是讲解C++的，所以它推荐读者尽量使用C++的内容，而实际上像我这样从C过来的人，还是习惯于使用C风格的字符串。——我又想起了那句话：“原来我只是一个‘古代’的C++程序员。”(见《数组》一文)
　　C语言是用字符数组来做字符串的（当然这个字符数组必需要有一个NULL结尾），因为字符串是如此常用，C语言还专门开发了一套库函数来处理这个特殊的数组。于是，我们进行字符串操作时，可以忘记指针、忘记循环、还可以忘记char这个内置类型。
　　正是因为如此，林锐博士的《高质量C++/C编程指南》中还特别强调，不可以用指针的赋值和比较来进行字符串的赋值和比较。这个警告对于从VB转过来的人尤其重要。
　　使用C风格的字符串有两点是必须保证的：一是要给这个数组开劈足够长度的空间；二是一定不要忘了NULL；其中第二点一般程序员不会犯错，因为毕竟没几个人用“chat s[3] = {'a', 'b', '/0'}”这种方式来定义字符串。第一点就成了重中之重。我们在strcpy之前，有没有考虑过目标字符串可能的空间不足？
　　“strn”风格的函数既救了大家也可能害了大家，说它救了大家，因为大家在strncpy和strncat时可以控制字符个数，即使源字符串太长，也可以避免内存溢出。但是它存在的危险性是它不会为目标字符串添加NULL。
　　所以，书写到这里再次做了一个提醒：“尽可能使用标准库类型string”——我都忘了这是第几次提醒了，本书一而再再而三地提醒读者不要做“古代”的C++程序员。

 

 

标题：：指针（三）指针与数组

指针和数组之间是什么关系呢？书中曰“密切相关”。其实，那简真就是同一回事嘛。用到指针的时候，你未必会用到数组；但是只要你用到数组，你就必要然用到指针（即使你不知道）。
　　正是因为指针可以用加或减运算来移动它所指的位置，而且每加一或减一正好移动到相邻一个同类型的变量（不管这个变量占内存是多少），那么我有意将一堆同类型的变量放在一起，拿一个指针指向它们中的第一个，再记住它们的个数，这就成了数组。
　　数组用一组方括号来解引用其中的某个成员，这也只是指针运算的简化。比如：
　　int a[10];
　　a[5] = 5;
　　以上这种代码谁都用过，谁都能理解。那么下面这行代码呢？
　　5[a] = 5;
　　这种用法恐怕很少有人知道，即使现在知道了，恐怕也很难理解。实际上知道了数组运算的实质，这行代码的迷雾就会立即消失：C/C++语言处理括号的方法很简单，将方括号前面的值和方括号内的值相加，得到一个新的指针，再取指针所指的对象值。“a[5]”就完全等价于“*(a+5)”，“5[a]”就完全等价于“*(5+a)”。
　　那么“*(a+5)”是什么运算呢？指针运算。因为在编译器处理“int a[10];”的时候，就等于定义了一个“int * const a;”同时将它初始化为指向栈内存的某处。
　　实际上，正是因为“*(a+5)”这种用法实在太常用了，C才规定了它的替代用法，后来这个替代用法被广为接受，而它的实际却被人遗忘。
　　以上内容本书未有提及，这是我看书看到这里的一点心得，作为读书笔记写下来。不是为了炫耀。本书虽然是给有一定基础的人读的，但是毕竟它只是按步就章地写下C++的语法规则，没有必要提及这些技巧性高而又实用性少的内容。我之所以要写下来，目的是为了便于理解指针运算。

 

 

标题：：指针（二）

指针的初始化与赋值：指针是一个变量，它可以被赋值，也可以被求值。指针可以接受的值只有以下几种：
　　1、编译时可求值的0值常量。（必须是0，其实就是NULL啦）
　　2、类型匹配的对象的地址。（也就是用&运算符取一个变量的地址）
　　3、另一对象末的下一地址。（这种用法主要用在循环里，其实当指针取这个值时，对其所指的内存进行存取往往会导致灾难）
　　4、同类型的另一个有效指针（如“p=q;”）。
　　其中第1点，将0值赋给指针，主要是为了有一个状态表示这个指针是“空的”。C/C++通常约定0为NULL，虽然的确存在地址为0的内存，但是别指望用指针来访问这个内存。
　　初学者怎样才能消除对指针的恐惧？我觉得首要的一点是清醒地认识并且时刻提醒自己“指针也是一个变量”。比如以下两行程序：
　　int i;
　　int *p = &i;
　　看到这儿的人几乎无一例外把p和i联系起来（这当然不是坏事），但是，我觉得更重要的是将p和i分离，心里记住，p是一个变量，该变量是有它的值的，这个值与i的唯一关系是：目前该值正好等于变量i在内存中的位置。两种情况下p与i将毫无关系：
　　1、p值被改变，如“p = &j;”或“p++;”
　　2、i变量被释放，如离开了i的作用域。

 

 

标题：：指针

指针是C/C++的精华，也是最难的部分。——所有学习C/C++的人都明白这点，当年我初学的时候也是这样。但是，现在再回想指针，我却很难回忆它究竟难在哪儿。应该说这就叫“难者不会，会者不难”吧。“饱汉不知饿汉饥”是有一定的道理的，即使饱汉曾经饿过。
　　本书中规中矩地讲解了指针的概念、定义与初始化、操作等。正如上面提到的“饱汉不知饿汉饥”，我似乎很健忘，以至于不记得指针的难点在哪儿了。
　　指针的灵活性可以把大量的工作化繁为易，前提是必须首很把足够繁的指针弄懂。听起来有点像绕口令，事实就是这样，你现在把难懂的东西弄懂了，日后可以把难事化简，大事化小。
　　从VB过来的人一定会熟悉“值传递”和“地址传递”这两个概念，实际上，“地址传递”这种说法正是为了弥补VB没有指针却有类似的需要才发明的。我认为C/C++程序员要想深入理解指针，首先要抛弃这个概念。在C/C++程序中，即使在函数调用中传递指针，也不能说“地址传递”，还应该说是值传递，只不过这次传递的值有点特殊，特殊在于借用这个值，可以找到其它值。就好像我给你一把钥匙一样，你通过钥匙可以间接获得更多，但是我给你的只不过是钥匙。
　　我前阵子曾写过一篇关于指针的文章，之所以写那篇文章，是因为看到一大堆初学者在论坛上提问。通过对他们提的问题的分析，我总结了几点。下面，首先就先引用我自己写的《关于指针》中的片段吧（完整的文章请到我的个人主页查找）：
　　一、指针就是变量：
　　虽然申明指针的时候也提类型，如：
　　char *p1;
　　int *p2;
　　float *p3;
　　double *p4;
　　.....
　　但是，这只表示该指针指向某类型的数据，而不表示该指针的类型。说白了，指针都是一个类型：四字节无符号整数（将来的64位系统中可能有变化）。
　　二、指针的加减运算很特殊：
　　p++、p--之类的运算并不是让p这个“四字节无符号整数”加一或减一，而是让它指向下一个或上一个存储单元，它实际加减的值就是它所指类型的值的size。
　　比如：
　　char *型指针，每次加减的改变量都是1；
　　float *型的指针，每次加减的改变量都是4；
　　void *型指针无法加减。
　　还要注意的是：指针不能相加，指针相减的差为int型。
　　正是因为指针有着不同于其它变量的运算方式，所以，在任何时候用到指针都必须明确“指针的类型”（即指针所指的变量的类型）。这就不难理解为什么函数声明时必须用“int abc(char *p)”而调用的时候却成了“a = abc(p);”这样的形式了。
　　三、用指针做参数传递的是指针值，不是指针本身：
　　要理解参数传递，首先必须把“形参”与“实参”弄明白。
　　函数A在调用函数B时，如果要传递一个参数C，实际是在函数B中重新建立一个变量C，并将函数A中的C值传入其中，于是函数B就可以使用这个值了，在函数B中，无论有没有修改这个C值，对于函数A中的C都没有影响。函数B结束时，会将所有内存收回，局部变量C被销毁，函数B对变量C所做的一切修改都将被抛弃。
　　以上示例中，函数A中的变量C称为“实参”，函数B中的变量C被称为“形参”，调用函数时，会在B函数体内建立一个形参，该形参的值与实参的值是相同的，但是形参的改变不影响实参，函数结束时，形参被销毁，实参依然没有发生变化。
　　指针也是一个变量，所以它也符合以上的规定，但是，指针存放的不仅仅是一个值，而是一个内存地址。B函数对这个地址进行了改动，改动的并不是形参，而是形参所指的内存。由于形参的值与实参的值完全相同，所以，实参所指的内存也被修改。函数结束时，虽然这个形参会被销毁，指针的变化无法影响实参，但此前对它所指的内存的修改会持续有效。所以，把指针作为参数可以在被调函数（B）中改变主调函数（A）中的变量，好像形参影响了实参一样。
　　注意：是“好像”。在这过程中，函数B影响的不是参数，而是内存。
　　下面再来看刚才的例子：“int abc(char *p)”和“a = abc(p);”。为什么申请中要用*号，因为函数必须知道这是指针；为什么调用时不加*号，因为传递的是“指针值”，而不是“指针所指内存的值”。
　　四、指向指针的指针：
　　正因为指针也是一个变量，它一样要尊守形参与实参的规定。所以，虽然指针做参数可以将函数内对变量的修改带到函数外，但是，函数体内对指针本身作任何修都将被丢弃。如果要让指针本身被修改而且要影响函数外，那么，被调函数就应该知道“该指针所在的内存地址”。这时，指针不再是指针，而是“普通变量”。作为参数传递的不是这个“普通变量”，而是指向这个“普通变量”的指针。即“指向指针的指针”。
　　如果p是一个指向指针的指针，那么*p就是一个指针，我们不妨就把它看成q。要访问q指针所指的内存，只要*q就是了。用初中数学的“等量代换”一换就知道，*q就是**p。
　　五、指针数组。
　　之所以要把“指针数组”单独提出来，是因为数组本身就与指针有着千丝万缕的关系。即使你不想用指针，只要你使用了数组，实际就在与指针打交道了。
　　只要理解了指针本身就是变量，就不难理解“指针数组”，我们可以暂且把它当成普通数组来处理，a[0]、a[1]、a[2]……就是数组的元素，只是，a[0]是一个指针，a[1]、a[2]也是一个指针。那a呢？当然也是指针，但这是两码事。你可以完全无视a的存在，只去管a[0]等元素。*a[0]与*p没有什么本质的区别。　　
　　还有一个东西不得不提一下，它比较重要：
　　指针的定义有两个可取的方式，它们各有优缺点：“int *p;”和“int* p;”是完全等价的，后者的好处是让人体会到p是一个“指向int的”指针，前者会让人误解为*p是一个int型变量（这里没有定义int型变量）；但是前者的好处是不会产生混淆，如“int *p, *q;”让人一眼就看出定义了两个指针，而“int* p,q;”会让人误解成定义了两个指针（实际上q不是指针）。

 

 

标题：：数组

进入本书第四章，开始讲“数组”了。数组难不难？这不好说。但是数组非常重要这是肯定的，有许多基本的算法就是与数组一起出现的——比如冒泡排序法。而离开了那些算法，数组本身也失去了价值。
　　注意：阅读本章时要对“维数”概念加以小心，按平时的理解，“维数”是多维数组中的概念，但是本书中的“维数”指的是元素个数。为了避免干扰，我在阅读笔记中用“个数”来取代“维数”。
　　引用：在出现标准库之前，C++程序大量使用数组保存一组对象。而现代的C++程序则更多地使用vector来取代数组，数组被严格限制于程序内部使用，只有当性能测试表明使用vector无法达到必要的速度要求时，才使用数组。
　　笔记：我汗一个先！原来我只是一个“古代”的C++程序员。
　　数组的定义必需指明元素的个数，而且必须是“常量表达式”。这一点想必理解数组的人都会操作（即使弄错了，编译器也会立即报错），但是真正去思考它的人也许不多。这里的“常量”概念是指程序在编译阶段就能求值的量。
　　在C时代，我们并不会过多地理会“常量”这个概念，那是因为C时代没有const，而define这个东西，谁都知道它是在编译前就直接替换的。但是到了C++时代，由于const的存在，使“常量”这个概念变得更普杂了。
　　const size1 = 5;//这是个编译时就可以求值的常量，它可以在数据的定义中使用。它的作用仅仅相当于“define”。
　　const size = getsize();//这个常量是运行时才能求值的。
　　除此之外，“常量求达式”的概念还指明这可是以一个算术式，只要编译时能求值。如“char username[max_name_size + 1];”这种用法非常常用，因为它可以避免在定义数组时忘掉NULL。
　　数组成员的初始化可以显式指定，也可以不指定。显式指定时指定成员的个数可以小于等于实际个数，但不可以比实际个数大，如果小于，则其它元素视为未指定。对于未指定的元素的初始值，它们遵循变量的初始化原则，请看《变量初始化》一文。
　　绝大多数书本在介绍“字符串”时都会提到，字符串其实是字符数组，只是因为它们太常用，才会有专门的使用方法。本书也不例外。
　　本书没有提数组的实质，因为“指针”还没有进入读者的眼睛。
　　引用：数组的显著缺点在于：数组的长度是固定的，而且程序员无法知道一个给定数组的长度。
　　笔记：其实这正在程序员心中的一个痛。当我把数组作为参数传送给函数时，函数该怎么处理这个东西？要么是对大小有个事先的约定——这样的程序将失去很多通用性，要么连大小一起传递给人家。

 

 

标题：：C++标准库，想说爱你不容易

第三章就这样结束了，本章介绍了三个标准库类型：string、vector和bitset。
　　可惜的是，整个第三章我都是草草读过的。一方面因为它们不属于严格意义上的C++内容，另一方面C时代的东西在不经意间抵触着它们。
　　确切地说，它们C时代的那些东西的替代品。它们存在的理由就是它们更优秀。然而优秀是一回事，动不动心又是一回事。
　　C语言在类与对象方面的缺失，使C程序员更多地掌握了底层的操作。面对C++标准库中的string和bitset这些东西，C程序员们都知道，在C++出来以前自己是怎样想方法解决过问题的。刻苦才有刻骨铭心，转到C++以后，是使用更简单安全的标准库，还是使用自己曾熟悉的老办法，这是一个取舍的问题。
　　引用：程序员应优先使用标准库类类型。
　　笔记：本书在这里放置了这样一个提示，大概是想告诫我这样的顽固派：“别再死纠着陈腐旧套不放了，回头吧。”其实，早在本书的前言就有了类似的内容。可是，我依然不能让自己静下心来细读并熟记第三章。
　　也许有一天我会回头重读第三章，当然，也许永远不会。因为像string和vector这样的东西，在MFC中还有更好的替代品。

 

 

标题：：标准库bitset类型

每当使用到布尔变量数组时，总是有点心疼。因为布尔变量只需要0和1两种值，然而编译器动辄使用一个字节——甚至四个字节来存放一个布尔变量。面对1/32的使用效率，叫人怎能不心疼？
　　要想节约空间也不是没有办法，代价是写更多的代码：用“&”操作将变量的某一个bit取出来，一个字节就可以存放8个布尔变量。但是，这个代价是比较重的，重到足以让程序员望而生畏的地步。
　　bitset应运而生，它可以方便地管理一系列的bit位而不用程序员自己来写代码。
　　更重要的是，bitset除了可以访问指定下标的bit位以外，还可以把它们作为一个整数来进行某些统计，如：
　　b.any();//b中是否存在置为1的二进制位？
　　b.count();//b中置为1的二进制位的个数
　　……
　　不过，话说回来，我还是不习惯用bitset，原因在于我是从C语言转到C++的。详细问题留到后一篇文章中讨论。

 

 

标题：：迭代器：指针与数据库杂交的后代

迭代器与数据库的相似之处在于end()函数返回值为“指向末元素的下一个”。跟数据记录集的eof这么相似。话说回来，熟练于C/C++的程序员一定不会忘了，利用下标访问数组时用的总是用“半开半闭区间”。就拿“int a[10]; for(int i=0; i!=10; i++)”来说，下标为10就可以视为“最后一个元素的下一个”。只是以前不会有这么明显的思考。
　　迭代器与指针的相似之处在于它的“解引操作符”，居然就是一个“*”号。而且存在着“ivec[n]”和“*ivec”这两个完全等价的操作。而且还支持算术运算来移动要访问的元素。
　　迭代的const用法与指针有个区别：
　　“vector<int>::const_iterator ivec = vec.begin();”定义的ivec并不是常量，只是它指向的元素会得到保护。如果要定义本身为const的迭代器，要用“const vector<int>::ivec = vec.begin();”。
　　指针是这样处理的：
　　const int *p = &i;//p指向的变量是const
　　int* const p = &i;//p是const
　　地雷：任何改变vector长度的操作都会使已存在的迭代器失败。例如，在调用push_back之后，就不能再信赖指向vector的迭代器的值了。
　　笔记：我不得不相信所谓的迭代器其本质就是一个指针了。因为vector支持动态增长，而且保证内存的连续。所以，每次改变它的长度都会导致释放已有内存、重新申请内存。指针当然得失效。

 

 

标题：：for语句的条件思考

对于for语句，我几乎总是这样写的：“for(int i=0; i<Max; i++);”。但是，按本书的说法，我这样写似乎同时犯了两个错误。
　　1、本书中写for语句中的第二个表达式（条件表达式）时总是用!=，而不用<。这几天来虽然心里觉得奇怪，但是一直没去思考这里面的含义。本书没有急着告诉我“所以然”，只是提醒我读完本书的第二部分后就会明白。我等着吧:)
　　2、我总是觉得用Max这样一个变量去代替某个需要用函数才能返回的值可以增加运行效率，但是本书的建议与我的理解相反。它建议用“i<ivec.size()”，“因为数据结构可以动态增长，……如果确实增加了新元素的话，那么测试已保存的size值作为循环结束条件就会有问题，因为没有将新加入的元素计算在内。”
　　同时，本书为了打消运行效率的顾虑，还提到了“内联函数”这个概念。现在还没有到介绍内联的时候，但是C++必须是一个有机体，在讲述某一个知识点的时候，不可能完全避免另一个知识点。所以，我还是建议初学者不要急着阅读本书。

 

 

标题：：标准库vector类型

终于让“类模板”上场了，可惜的是，在本书的第三章，还不能彻底让类模板浮出水面，只能将就着提一下。
　　引用：使用类模板可以编写一个类定义或函数定义，而用于多个不同的数据类型。……vector并不是一种数据类型，而只是一个类模板，可用来定义任意多种数据类型。
　　笔记：“vector<int> ivec;”中，“vector<int>”是一个数据类型，C++支持类模板，以后大量接触类模板时，这个一定要时刻注意。
　　引用：在元素值已知的情况下，最好是动态地增加元素。……虽然可以对给定元素个数的vector对象预先分配内存，但是更有效的方法是先初始化一个空的vector对象，然后再动态地增加元素。
　　将vector与string对比，可以轻松地记住empty()、size()函数和[]、=、==、!=等运算符。不过这似乎有个前提：对C语言比较熟并且摈弃VB的String变量类型。因为，string虽然是一个变量，但是如果缺少对“char []”的理解，将注定不能理解它。——所以，我很反对某些人说的“可以不学C语言直接学C++”论调。

 

 

标题：：标准库string类型

习惯了VC++的CString类，而此前用的又是C语言，所以，压根没有看一眼string。现在既然书中专门讲它，我就看一看吧。
　　定义与初始化：
　　string s1;
　　string s2(s1);
　　string s3("value");
　　string s4(n, 'c');//由n个c组成的一串
　　string对象的输入除了可以“cin >> s1;”以外，还可以将cin和string对象一起作为getline()函数的参数“getline(cin, s1);”，而且这个函数的返回值还是cin。
　　除此之外，string类还有empty()、size()等函数和[]、+、=、==等运算符。
　　地雷：empty()函数的功能并不是将对象置空，而是测试是否为空。这可是与CString类的Empty()函数不一样的哦！
　　本书还详细介绍了empty::size_type类型存在的原因。在使用VC++.NET的时候，我已经见过了size_t类型——strlen()函数的返回值就是size_t类型对象。当时我也没有细究这个东西，想来应该是为了支持64位机而设的吧。不过现在我知道了，原来我想得还不够。
　　引用：通过这些配套类型，库类型的使用就能与机器无关。
　　关于“+运算必须至少包含一个string类型”，这可能让初学者摸不着头脑。比如“s1 + s2”、“s1 + "hello"”、“"hello" + s1”是合法的，唯独“"hello" + "world"”不合法。我在看懂“运算符重载”之前也没有明白这个。本书由于刚开头，离“运算符重载”还远着呢，所以只告诉读者“然”、没有告诉读者“所以然”。我也不写了。
　　引用：下标操作可作左值。
　　笔记：人类一思考，上帝就发笑。这就是一个例证。下标操作可作左值有什么好说的？早就用过啊？比如“char s[]="abcde"; s[2]='t';”。可是现在的不是指针变量，而是类成员，对于“string s("abcde");”来说，“s[n]”就不是简单操作一个内存了，而是从“[]重载函数中返回了一个值”。这个值可以做左值，并不是想当然的事。

 

 

标题：：命名空间的using声明

虽然实际工作中绝少用到cin和cout，但是我还是记得要用它们必先“using namespace std;”，至于为什么这样做，三个字：不知道。
　　本书从一开头就用到了cin和cout，但是它没有using，而是每一次用到它们都写成“std::cin”和“std::cout”，同时提醒说这两个字名是来自std命名空间的。于是，我似乎明白了“using namespace std;”的作用。
　　也许是C++实在太难，作者迟迟不介绍更深入的内容，到了第一部分、第三章，还没有打算深入using，但又不得不讲一点，于是提了这样两行：
using std::cin;
using std::cout;
　　至此，究竟什么是命名空间，命名空间是干什么的，我还是不懂。也许书后面会提吧。

 

 

标题：：头文件

头文件的用处主要是代码重用——重用不仅仅是为了减少工作量，还可以保证每一次重用都是完全相同的内容。
　　正因为头文件可以多次重用，所以要防止有些只能出现一次的代码放进头文件中。比如变量的定义只能有一次，声明（含extern且不含初始化）却可以有多次。函数也是。
　　引用：一些const对象定义在头文件中。
　　笔记：看到这里，总算想通了前面的困惑：为什么const常量的作用域仅为一个文件。正如我前面的估计，const常量是不开劈内存空间的，代码在编译的时候就被直接替换成常量值。而且，编译器对多个CPP是分开编译的。所以，它必须要编译的时候知道该常量的值。如果常量的作用域也是全局的，那么我告诉编译器“该常量的值在另一个CPP中”将使其无可适从。
　　避免头文件被重复包含是个比较有岐义的说法，头文件既然可以被多次包含，为什么又要避免重复包含？还是因为CPP文件的单独编译。在编译任一个CPP文件时，都要知道文件的内容，所以，如果两个CPP都包含了同一个头文件，那么头文件就要被编译两次。但是同一个CPP如果重复调用——甚至可能循环调用——了某一个头文件，则要及时避免。#ifndef...#define...#endif可以起到这个作用。
　　对了，我一直没想通VC++.NET的“#pragma once”是怎么工作的。它为什么不需要用变量来标记不同的头文件？为什么只需要一行也能标记出整个头文件的所有内容？
　　第一部分、第二章结束。

 

 

标题：：class与struct

首次考虑class与struct的关系源自我对类对象占用内存数的观察。我发现VC++6的CString——这么强大的类——它占内存居然是4字节（sizeof(CString)为4）。那时我就认为，类对象仅仅在内存中存放成员变量（《C++ Primer》称作“数据成员”）而不存放成员函数。后来，读林锐博士的《高质量C/C++编程指南》时，才看到了比较正规的说法：C++中class与struct没有本质的区别。——当时我将这句话给我朋友看时，他还表现出不相信的神色。
　　读《C++ Primer》时，我已经熟知了class与struct的关系。但是我还是细细地没有放过书中的任何一个字，还是作点记录吧：
　　引用：用class和struct关键字定义类的唯一差别在于默认访问级别：默认情况下，struct的成员为public，而class的成员为private。
　　笔记：不过，一般情况下公司与公司间规定协议时，喜欢将类定义写成struct，我想这可能是源于程序员从C语言继承来的习惯，还有就是协议内容一般只包含数据，不包含函数，也没有必要规定安全的访问级别。
　　引用：编程新手经常会忘记类定义后面的分号，这是个很普通的错误！
　　笔记：书中将这段文字标作一个地雷，我还是引用一下吧。

 

 

标题：：枚举

枚举是我向来不太喜欢用的东西，几乎我见过的每本书都是这样介绍枚举的：
　　enum weekday {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
　　我看到这里，总是想：多浪费啊，与其这样，还不如直接用0-6这些数呢。以后要写“weekday Today = Sunday;”，哪有“int Today = 0;”舒服。
　　本书似乎早看透了我的心理，于是，讲枚举不从枚举入手，偏从const常量入手：
　　引用：
　　const int input = 0;
　　const int output = 1;
　　const int append = 2;
　　虽然这种方法也能奏效，但是它有个明显的缺点：没有指出这些值是相关联的。枚举提供了一种替代方法，不但定义了整数常量集，而且还把它们聚集成组。
　　笔记：大师就是大师，他们写书能切中要害，让读者明白标准制定者的苦心。　　
　　另外，本书在这儿冷不丁地提了一个冷冰冰的概念：常量表达式。
　　引用：常量表达式是编译器在编译时就能够计算出结果的整型表达式。整型字面值常量是常表达式，……
　　笔记：让我先汗一个。常量表达式必需是整数？我怎么不知道？那“double pi = 3.14159;”后面的字面值不属于常量表达式吗？这是个疑问，先记下来。
　　引用：枚举类型的对象的初始化或赋值，只能通过其枚举成员或同一枚举类型的其它对象来进行。
　　笔记：这跟现实生活中的“做人要专一”有点相似，呵呵。简单地说，你选择了用名字来代替数值，那就得始终如一地使用名字，不可以用数值或其它表达式。比如“weekday Today = Sunday;”不可写成“weekday Today = 0;”，虽然Sunday就是0。

 

 

标题：：typedef

长期以来，我一直在疑惑：typedef这个词要它干什么？因为没有它我照样可以完成所有任务。而有了它我反而觉得无法适应。比如“UINT i;”，为什么不写作“unsigned int i;”？本书用简短的三句话告诉我它存在的意义：
　　引用：typedef通常被用于以下三种目的：为了隐藏特定类型的实现，更强调使用类型的目的；简化复杂的类型定义，使其更易理解；允许一种类型用于多个目的，同时使得每次使用该类型的目的明确。
　　笔记：第三种目的对我的启发特大。以后就“typedef unsigned int age;”，呵呵。

 

 

标题：：引用

引用是C++的特色，一般用在函数的参数中。按有些书本的说法，叫“普通变量的用法，指针变量的效果”。书中本节没有讲诉引用在函数参数中的用法，只提了“给变量起个别名”这一个用处（毕竟本书才开头）。说实在的，如果撇开函数参数，还真想不到引用有什么用处。
　　引用这个概念本身也不难理解（除了对C程序员来说有些不习惯以外），但是引用的符号却增加了理解它的难度，我经常在论坛上看到有初学者对“&”和“*”两个符号的疑惑，他们问的问题可以说非常基础，但却表现出了这个问题的难以理解的特点：
　　C语言中的指针已经够复杂的了，加再上一个引用，引用与指针有着千丝万缕的联系，这就算了，而且还用了“&”这个符号。真让初学者忙昏了头。呵呵。下面四行程序，用到了两个“&”和两个“*”，但是它们的意义却全然不同：
int a;
int &b = a;//&用在定义中仅表示变量的性质为引用
int *c = &a;//*用在定义中仅表示变量的性质为指针，&用在表达式中表示取地址
int d = *c;//*用天表达式中表示取指针变量所指的变量的值
　　写下以上文字，我觉得有些越权了。这些内容估计在本书后面会详谈的，我心急了点。

 

 

标题：：const常量的作用域仅为一个CPP文件

如果将变量定义放在任何{}的外面，则该变量是全局的，这个规则不适用于const常量。
　　以前虽然心里隐隐约约有这个感觉，但是从未正面考虑过这个问题。之所以隐隐约约有此感觉，是因为我认为编译器并不为const常量开劈内存空间。
　　我曾经专门做过测试：程序如下：
const int i = 5;
int *p;
p = (int *)&i;
cout << *p << "/t" << i << endl;
(*p)++;
cout << *p << "/t" << i << endl;
　　测试结果发现const常量也是可以通过某些途径改变其值的，但是改变不起作用。我的解释是，编程器在生成机器码时将所有的i直接替换成了5。使得上面两个cout语句都成了“cout << *p << "/t" << 5 << endl;”。
　　回想起以前做过的测试，便不难理解“const常量的作用域仅仅为定义它的CPP文件”，因为编译器是对每个CPP文件单独编译的，只有在连接时才会去理会CPP之间的关系。虽然本书才看了个开头，书中还说“我们将会在2.9.1节看到为何const对象局部于文件创建”。我不打算跳跃式地阅读本书，所以，我还是先保留我自己的理解吧。
　　const常量也还是可以成为全局常量的，方法是在定义的时候就加上extern。看到这里，我终于明白了《extern的困惑》中的困惑：原来，那种“有些多余，而且增加了出错的可能性”的做法在常量的处理上派上了用场。

 

 

标题：：变量的作用域

作用域这个概念是程序员都耳熟能详的知识点。这部分知识我几乎可以跳过，不过我还是认真阅读了相关内容。阅读过程中还是有体会的：
　　有无数书本曾经提醒过我：少用（尽量不用）全局变量，多用局部变量。其实，即使是局部变量，也还有作用域大小的，局部变量的作用域也是越小越好。原因自然和少用全局变量一个道理。正如书中所言：“通常把一个对象定义放在它首次使用的地方是一个很好的办法。”
　　以往，我使用局部变量总是把它放在函数的开头，表示这些变量在本函数中起作用。唯一的例外是for语句的循环变量（for (int i=0; i<Max; i++);）。以后我就改改，把局部变量的作用域缩小到仅仅用到它的语句块。

 

 

标题：：extern的困惑

extern用来告诉程序：你不用为我的变量开劈内存空间，你只要知道这个变量别处已经声明过了。所以，我总是在程序包含多个CPP文件时才这样用：
　　1、在某一个CPP文件中直接定义变量，如int i = 0;
　　2、其它CPP文件中声明变量，如extern int i;
　　但是，书中介绍exturn还可以用来定义，如：extern double pi = 3.1416;特点是该extern语句包含变量的初始化。
　　我觉得C++标准这样做有些多余，而且增加了出错的可能性。因为“extern double pi = 3.1416;”完全可以用“double pi = 3.1416;”来代替，这样做可以让定义与声明划清界线。毕竟定义只能有一次，而声明可以无数次。如果没有这个特性，可以让程序员简单记为“不带extern的只能有一次，带extern的可以有无数次，而且extern同时不能指定初始值。”这一特性的支持，使原本简单的规则变得复杂，但没有带来灵活（众所周知，C++的复杂是以高度灵活为补尝的）。
　　这个段落还让我认识到了我以前使用extern的不足。我以往在同一个CPP文件中只使用一次extern，所以我往往是在文件头部用extern语句来声明一下变量，这样做虽然没有什么错，但却会导致上下翻查：有时在文件的某一处用到变量时，想看一下它的声明，不得不把滚动条拖到顶上去查看。如果在用到它的段落开头处再声明，明显比顶部声明要好一些。

 

 

标题：：变量初始化

int ival(1024);//直接初始化
　　int ival = 1024;//复制初始化
　　以前的我常用第二种用法，原因很简单：从来没见过第一种用法。直到后来学习了林锐博士的《高质量C/C++编程指南》。
　　那本书在讲类的构造时说道：CMyClass b = a;这种形式看起来像赋值，实际上调用的是拷贝构造函数。
　　那本书给我的感觉仅仅停留在类变量的初始化中，一直没有过渡到内置变量类型。直到后来，我在用VC++.NET的向导功能编程序时，才发现向导帮我产生了类似于“int i(100);”这种语法来初始化。
　　本书重点强调：初始化不是赋值，
　　引用：当定义没有初始化的变量时，系统有时候会帮我们初始化变量。这时，系统提供什么样的值取决于变量的类型，也取决于变量定义的位置。……内置类型变量是否初始化取决于变量定义的位置。在函数体外定义的变量都初始化为0，在函数体内定义的内置类型变量不进行自动初始化。……（类类型）通过定义一个特殊的构造函数即默认构造函数来实现的。这个构造函数被称作默认构造函数，是因为它是“默认”运行的。……不管变量在哪里定义，默认构造函数都会被使用。
　　笔记：林锐博士的《高质量C/C++编程指南》中说，如果类没有定义无参数构造函数或拷贝构造函数，系统会自动产生这两个构造函数，它们采用最简单的“值传递”和“位拷贝”来完成构造。

 

 

标题：：变量和变量名

引用：对象是内存中具有类型的区域。
　　笔记：这句话说得很直白，也只有这样面向C++熟练工的书才可以这样说，毕竟初学者不知道内存与变量的关系，或者还没考虑到。

　　引用：C++还保留了一些词用作各操作符的替代名。这些替代名用于支持某些不支持标准C++操作符号集的字符集。它们也不能用作标识符（此处指变量名，偷猫标）。
　　一般的书只提到C++变量名不可以使用关键字，本书还额外提了这样一句，然后列出一个表，有and、bitand、compl、not_eq、or_eq、xor_eq、and_eq、bitor、not、or、xor。不过据我在VC++.NET上测试，这些是可以用作变量标识符的。

　　都说变量名可以含“_”，还可以用“_”开头，但我一直没有试过光光用一个“_”来做变量名，正好习题里有，我就试了一下，果然可以的。

 

 

标题：：cout << (wchar_t类型变量)体验

《C++ Primer》说了，字符常量或字符串常量前加L，表示wchat_t类型，于是我试了一下：

程序如下：
char a = "a";
wchar_t b = L"a";
cout << a << endl;
cout << b << endl;
结果如下：
a
0012FEBC
晕，怎么出现这个结果？
让我再试。

程序如下：
char a = 'a';
wchar_t b = L'a';
cout << a << endl;
cout << b << endl;
结果如下：
a
97

由此可见，cout的<<运算符没有对wchat_t的重载（或不健全）。

 

 

 

标题：：内置类型之精度选择

引用：……大多数通用机器都是使用和long类型一样长的32位来表示int类型。整型运算时，用32位表示int类型和用64位表示long类型的机器会出现应该选择int类型还是long类型的难题。在这些机器上，用long类型进行计算所付出的运行时代价远远高于用int类型进行同样计算的代价。……决定使用哪种浮点型就容易多了：使用double类型基本上不会有错。在float类型中隐式的精度损失是不能忽视的，而double类型精度代价相对于float类型精度代价可以忽略。事实上，有些机器上，double类型比float类型的计算要快和多。long double类型提供的精度通常没有必要，而且还需要承担额外的运行代价。

 

 

标题：：内置类型之int和bool

第一部分，第二章
　　引用：C++标准规定了每个算术类型的最小存储空间，但它并不阻止编译器使用更大的存储空间，事实上，对于int类型，几乎所有的编译器使用的存储空间都比所要求的大。
　　笔记：确实如此，VC++中int和long是一样大。VC++.NET增加了对_int64的支持。
　　引用：字符类型有两种：char和wchar_t，wchar_t类型用于扩展字符集，比如汉字和日语。
　　笔记：我怎么不知道wchar_t？我自己用包含汉字的字符串时用的也是char。:(
　　看到bool型，我心里对VC++有些气愤。因为VC++里有一个BOOL宏。它的原型为“typedef int BOOL”。既然C++标准已经有bool型，VC++加入BOOL的用意很明显：迎合更多的编程习惯。但是，即使非要增加对BOOL的支持，我认为原型应该这样：“typedef bool BOOL”，这样更易于理解。
　　当然了，长期以来我一直没有注意到bool确实也不应该。但是正是BOOL的存在，阻碍了我对bool的理解。

 

 

标题：：第一章：快速入门

第一章：快速入门
　　本章的存在使本书变得不像一本“规范书”，似乎成了“入门书”，这可能是后来版本新加入的内容。以至于这一章节被排除在任何一个“部分”之外。
　　本章“无厘头”地简要介绍了cin、cout、注释、while、for、if等概念。这么多东西，每一个都介绍点皮毛，然后组合成一个综合实例。
　　我称其为“无厘头”有以下原因：如果本书面对不了解C++的读者，那么这一章似乎是有用的，但是C++的入门者使用本书显然很难入门，我不了解国外的情况怎样，至少我身边的人是这样；如果本书面对已经了解C++的读者，那么，这些东西都不用介绍，读者也可以看懂那个“综合实例”，而且所谓的“综合实例”也没有存在的必要。

不过有一个小小的收获：
int main()
{
  return -1;
}
如果返回值为-1，Windows的CMD中运行也没有任何额外信息，说明Windows并不报告运行失败。

 

标题：：《〈C++ Primer〉阅读笔记》前言

在读本书之前，我已经有过一段编写C++程序的历史，如果连C语言也算在内，可以追溯到十年前。用BASIC语言编程序的历史则有十四年(1992-2006)。
　　长期编程序中所使用的参考书无非有两种：介绍算法的书和介绍语法的书。我所买的参考书往往是同时介绍两者的。而对语法的介绍，则只是基于某一个编译器。
　　于是，这十年来，我所学习的“C/C++”，从本质上说只是Turbo C和Visual C++，对C/C++本身的理解也是被编译器过滤的内容。不是我不想去了解C/C++的本质，只是我对C/C++的“法典”有着与生俱来的恐惧。
　　这个恐惧直到我发现了《C++ Primer中文版》，当我捧起这本C++的“圣经”时，我终于能理解为什么每有几十万人冒着被踩死的危险前去朝圣。
　　请允许我用“圣经”来比喻这本书，我知道这样并不合适，因为绝大多数中国人并不知道“圣经”的地位，但是我搜遍大脑的每一个角落也找不到其它合适的比喻。这源于中国人缺乏信仰。
　　在半年前，我曾经带着无限的敬仰阅读了林锐博士的《高质量C/C++编程指南》，并且及时培养/修正了我的编程习惯。当然了，正如《C++ Primer》所言：“什么是C或C++程序的正确格式存在着无休止的争论……”。所以，我所修正的只是“自由体”，而不是与林锐矛盾的方面。令我感到欣慰的是，《C++ Primer》居然也用一定的笔默来讲格式与风格，不同的是，它同时介绍几种风格，然后作出一个略带倾向性的建议。同时，书中还告诫读者：“一旦选择了某种风格，就要始终如一地使用。”
　　从现在起，我就要捧起这一本四五厘米厚、七百多页的圣经，在阅读过程中，难免会有重点、要点要记录。我比较爱书，不愿在书上做标记，只好选择了BLOG这种形式来做读书笔记。
　　谨以此作为我的BLOG开篇说明吧。