--By Nathan.Yu 2007-11-29--

3 资源管理(之三)

条款15：在资源管理类中提供对原始资源的访问（Provide access to raw resources in resource-managing classes）

许多APIs需要指涉指针。

将RAII class对象转换为原始资源的方法：

1、  显式转换：

tr1::shared_ptr和auto_ptr都提供一个get成员函数，用来执行显式转换。也就是返回智能指针内部的原始指针。

2、  隐式转换：

①、重载指针取值操作符(operator->和operator*)。

②、提供一个隐式转换函数：operator T() const{return x;}。但这个隐式转换会增加错误发生机会。

是否该提供一个显式转换函数或隐式转换函数，主要取决于RAII class被设计执行的特定工作，以及它被使用的情况。通常get函数更好，因为它将“非故意转换”的可能性最小化了。然而有时候，隐式转换所带来的“自然用法”也会引发天平倾斜。

RAII classes并不是为了封装某物存在的，它们的存在是为了确保一个特殊行为——资源释放——会发生。

请记住：

1、             APIs往往要求访问原始资源（raw resources），所以每一个RAII class应该提供一个“取得其所管资源”的方法。

2、             对原始资源的访问可能经由显式转换或隐式转换。一般而言显式转换比较安全，但隐式转换对客户比较方便。

--By Nathan.Yu 2007-11-28--

3 资源管理(之二)

条款14：在资源管理类中小心copying行为（Think carefully about copying behavior in resource-managing classes）

 “当一个RAII对象被复制时，会发生什么？”这是每个RAII class作者必须面对的一般化问题。有4中可能：

1、  禁止复制。（见条款6： Uncopyable类）

2、  对底层资源祭出“引用计数”(reference-count)。通常只要内含一个tr1::shared_ptr成员变量，RAII class便可实现出referenct-counting copying行为。即将成员T*改为tr1::shared_ptr<T>。

tr1::shared_ptr的缺省行为是“当引用次数为0时删除所指对象”。但tr1::shared_ptr允许指定“删除器”（deleter）——是一个函数或函数对象(function object)，当引用次数为0时被调用。“删除器”（deleter）作为tr1::shared_ptr构造函数的第二个参数传入。

3、  复制底部资源。——“深度拷贝”，比如字符串类，当复制发生时，不论指针或指针所指内存都要被复制。

4、  转移底部资源的拥有权。如auto_ptr。

请记住：

1、             复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。

2、             普遍而常见的RAII class copying行为是：抑制copying、施行引用计数法。不过其他行为也都可能被实现。

--By Nathan.Yu 2007-11-27--

3 资源管理(之一)

常见的资源：文件描述器（file descriptors）、互斥锁（mutex locks）、图形界面中的字型和笔刷、数据库连接、网络sockets。

不论哪一种资源，重要的是，当你不再使用它时，必须将它还给系统。

条款13：以对象管理资源（Use objects to manage resources）

auto_ptr是一个“类指针(pointer-like)对象”，也就是所谓的“智能指针”，其析构函数自动对其所指对象调用delete。

RAII（Resource Acquisition Is Initialization）：资源取得即初始化。

<注意>由于auto_ptr被销毁时会自动删除它所指之物，所以别让多个auto_ptr同时指向同一对象。为了预防这个问题，auto_ptrs有一个不寻常的性质：

       若通过copy构造函数或copy assignment操作符复制它们，它们会变成null，而复制所得的指针将取得资源的唯一拥有权！

由于这一诡异的复制行为，加上“受auto_ptrs管理的资源必须绝对没有一个以上的auto_ptr同时指向它”，意味着auto_ptr并非管理动态分配资源的神兵利器。

       STL容器要求其元素发挥“正常”赋值行为，因此不能用auto_ptr管理它们。

auto_ptr的替代方案是“引用计数型智能指针”(reference-counting smart pointer, RCSP)。

RCSPs提供的行为类似垃圾回收(GC, garbage collection)，不同的是RCSPs无法打破环状引用（cycles of reference， 例如两个其实已经没被使用的对象彼此互指，好像还处在“被使用”状态）。

RCSPs举例：tr1：：shared_ptr

<注意>auto_ptr和tr1：：shared_ptr两者都在析构函数内做delete而不是delete[]动作。意味着两者都不能用在动态分配的数组上。

对数组可用容器如vector等代替。

然，boost::scoped_array和boost::shared_array则提供了上述管理数组的能力。

请记住：

1、             为防止资源泄漏，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源。

2、             两个被使用的RAII classes分别是tr1::shared_ptr和auto_ptr。前者通常是较佳选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它（被复制物）指向null。

--By Nathan.Yu 2007-11-24--

2 构造/析构/赋值运算(之四)

条款08：别让异常逃离析构函数

C++并不禁止析构函数吐出异常，但它不鼓励你这样做!

理由：

       设：std::vector<Widget> v;

假设v中有多个Widget，在销毁v的过程中，当有2个以上的Widget在销毁的时候抛出异常，对C++而言就太多了。在两个异常同时存在的情况下，程序若不是结束执行就是导致不明确行为。

       只要是在析构函数吐出异常，即使并非使用容器，程序也可能过早结束或出现不明确行为。

       如果程序在析构函数中捕获异常，“强迫结束程序，即调用abort”是个合理的选项。可以抢先制“不明确行为”于死地。

       另，将异常吞没是个坏主意。因为它压制了“某些动作失败”的重要信息。为了让这成为一个可行的方案，程序必须确保能够继续可靠地执行，即使在遭遇并忽略一个错误之后。

       更好地做法是，赋予客户一个处理异常的机会。如果某个操作必须在析构函数中使用，它又可能抛出异常，则将这个操作作为一个公共的接口，允许客户手动调用，让客户自处理异常。在析构函数中，判断客户是否调用过该函数，如若没有，则再次调用，并对可能抛出的异常进行处理。

       总之，如果某个操作可能在失败时抛出异常，而又存在某种需要必须处理该异常，那么这个异常必须来自析构函数以外的某个函数。

请记住：

1、             析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它或结束程序。

2、  如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。

【备注】参见More Effective C++： 条款十一：禁止异常信息（exceptions）传递到析构函数外

条款09：绝不在构造和析构过程中调用virtual函数

<注意>这是C++与Java或C#不同的一个地方

1、Base class构造期间virtual函数绝不会下降到derived classes阶层。

2、在base class构造期间，virtual函数不是virtual函数。

3、在derived class对象的base class构造期间，对象的类型是base class而不是derived class。因此，不止vritual函数会被编译器解析为base class，若使用运行期类型信息（如dynamic_cast或typeid），也会把对象视为base class类型。

4、对象在derived class构造函数开始执行前不会成为一个derived class 对象。

相同道理也适用于析构函数。

解决方案：改用non-virtual函数，并要求derived class构造函数传递必要信息给base class构造函数，base class构造函数中调用non-virtual，该函数根据不同的信息处理不同的derived class。

请记住：

在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class。

条款10：令operator=返回一个reference to *this

协议：为了实现x=y=z=15之类的“连锁赋值”，赋值操作符必须返回一个引用指向操作符的左侧实参。

这个协议适合于所有赋值相关运算（operator op=）。

请记住：

令赋值（assignment）操作符返回一个reference to *this。

条款11：在operator=中处理“自我赋值”

什么情况发生“自我赋值”？

情况1：Widget w;       w = w;

情况2：a[i] = a[j]; //潜在的自我赋值，当i == j时

情况3：*px = *py; //px、py恰巧指向同一个对象。

详细分析operator=时可能出现的情况：

假设类：

class Bitmap{……};

class Widget{

……

private:

       Bitmap* pb;

};

operator=的不同实现版本：

版本1：一份不安全的实现版本，不具“自我赋值安全性”，不具“异常安全性”

Widget&

Widget::operator=(const Widget& rhs)

{

       delete pb;

       pb = new Bitmap(*rhs.pb);

       return *this;

}

这里的自我赋值是，*this和rhs有可能是同一个对象。果真如此delete就不只是销毁当前对象的bitmap了，也销毁rhs的pb。那么*this将持有一个已被删除的对象。

版本2：使用“证同测试(Identity test)”阻止版本1中的错误，达到“自我赋值”的检测目的，具“自我赋值安全性”，不具“异常安全性”

Widget&

Widget::operator=(const Widget& rhs)

{

       if(this == &rhs) return *this;

       delete pb;

       pb = new Bitmap(*rhs.pb);

       return *this;

}

这里，new Bitmap可能导致异常（不论是因为分配内存不足或因为Bitmap的拷贝构造抛出异常），Widget会持有一个指针指向一块被删除的Bitmap。

版本3：忽视“自我赋值”，把焦点放在实现“异常安全性上”，因为让operator=具备“异常安全”往往自动获得“自我赋值安全”的回报。

<注意>“许多时候一群精心安排的语句就可以导出异常安全（以及自我赋值安全）的代码”，例如：

Widget&

Widget::operator=(const Widget& rhs)

{

       Bitmap* pOrig = pb; //记住原先的pb

       pb = new Bitmap(*rhs.pb); // 令pb指向*pb的一个副本

       delete pOrig; //删除原先的pb

       return *this;

}

它或许不是处理“自我赋值”的最高效办法，但它行得通。

版本4：copy and swap技术，处理“自我赋值”的一个简单而通用的技术，并且是“异常安全的”（该版本的详细讨论可参考Exceptional C++）

Widget&

Widget::operator=(const Widget& rhs)

{

       Widget temp(rhs);

       swap(temp);

       return *this;

}

请记住：

1、             确保当对象自我赋值时operator=有良好的行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap。

2、             确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正常。

条款12：复制对象时勿忘其每一个成分

如果你为class添加一个成员变量，你必须同时修改copying函数(copy构造，copy赋值)，也需要修改所有其他构造函数以及任何非标准形式的operator=。

任何时候只要你承担起“为derived class撰写copying函数”的重责大任，必须很小心的复制其base class成分。那些成分往往是private的，所以你无法直接访问它们，你应该让derived class的copying函数调用相应的base class函数。

能否令某个copying函数调用另一个copying函数？不能！

令copy assignment操作符调用copy构造函数是不合理的，因为这就像试图构造一个已经存在的对象。

令copy构造函数调用copy赋值操作符同样无意义。构造函数用来初始化新对象，而赋值操作符只施加于已初始化对象身上。

使用private的函数init()来消除重复代码。

请记住：

1、         copying函数应该确保复制“对象内的所有成员变量”及“所有base class成分”。

2、         不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第三个函数中，并由两个copying函数共同调用。

--By Nathan.Yu 2007-11-15--

2 构造/析构/赋值运算(之三)

条款07：为多态基类声明virtual析构函数

问题：何时该声明virtual析构函数，何时不该这样做？

【要点摘录】C++明确指出，当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义——实际执行时常发生的是对象的derived成分没被销毁。造成“局部销毁”对象。消除这个问题的做法很简单：

       给base class一个virtual析构函数。

任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数。

如果class不含virtual函数，通常表示它并不意图被用做一个base class。当class不企图当作base class，令其析构函数为virtual往往是个馊主意。

无端的将classes对析构函数声明为virtual，就像从未声明它们为virtual一样，都是错误的。许多人都心得是：

       只有当class内至少含一个virtual函数，才为他声明virtual函数。

如果你曾经企图继承（作为多态继承，一般是public继承）一个标准容器或任何其他“带有non-virtual析构函数”的class，拒绝诱惑吧！（很不幸，C++没有提供类似Java的final classes或C#的sealed class那样的“禁止派生”机制）。

当你需要一个抽象类，但没有任何可用的pure virtual时（可能是其他的virtual函数都有默认实现），可以声明一个pure virtual析构函数。因为，抽象类总是企图被当作一个base class来用，做为base class就必须有个virtual析构函数，而pure virtual导致抽象类，因此可以声明一个pure virtual析构函数，使其成为抽象类。但必须为这个pure virtual析构函数提供一份定义，否则会发生链接错误。因为在销毁派生对象时，最终会调用这个抽象类的析构函数。

“给base classes一个virtual析构函数”，这个规则只适用于带多态性质的base classes身上。这种base classes的设计目的是为了用来“通过base class接口处理derived class对象”。

并非所有的base class的设计目的都是为了多态用途的。某些类的设计目的是仅仅作为基类实现代码复用，但不是为了多态用途（它们没有任何virtual函数），由于它们不被设计用来“经由base class接口处置derived class 对象”，因此它们不需要virtual析构函数。

请记住：

1、             polymorphic(带多态性质的)base classes 应该声明一个virtual析构函数。如果class 带有任何virtual函数，它就应该拥有一个virtual析构函数。

2、             Classes的设计目的如果不是作为base classes使用，或不是为了具备多态(polymorphically)，就不该声明virtual析构函数。

--By Nathan.Yu 2007-11-14--

2 构造/析构/赋值运算(之二)

条款06：若不想使用编译器自动生成的函数，就该明确拒绝

【要点摘录】所有编译器生成的函数都是public且inline的。

如何阻止拷贝行为？

将copy构造函数和copy assignment操作符声明为private，并不去定义（实现）它们。借由明确声明一个成员函数，阻止了编译器暗自创建其专属版本；而令这些函数为private，可以阻止人们调用它；只声明而不实现，则如果在成员函数或friend函数中调用它们，会产生链接错误。

【扩展】C++ iostream就是使用这个方法来组织copying行为的。

一个更好的方法：

把链接期错误移至编译期，并可复用代码。即使用Uncopyable base class阻止拷贝：

class Uncopyable{

protected:          //允许derived对象构造和析构

       Uncopyable(){}

       ～Uncopyable(){} //不一定得是virtual

private:

       Uncopyable(const Uncopyable&)；//阻止copying

       Uncopyable& operator=(const Uncopyable&)；

};

/*

不含数据成员，符合EBO(empty base class optimization)资格

总是扮演base class角色，导致多重继承。而多重继承有时会阻止EBO。

Boost版本：noncopyable。

*/

class MyClass: private Uncopyable{ // 使用私有继承

       ………..

};

请记住：

为驳回编译器自动提供的机制，可将相应的成员函数声明为private并且不予实现。使用像Uncopyable这样的base class也是一种做法。

--By Nathan.Yu 2007-11-13--

2 构造/析构/赋值运算(之一)

条款05：了解C++默默编写并调用哪些函数

如果你自己没声明，编译器就会为类声明一个copy构造函数、一个copy assignment操作符和一个析构函数。此外如果你没声明任何构造函数，编译器也会为你声明一个default构造函数。只有当这些函数被需要（被调用），它们才被编译器创建出来。

注意：编译器产出的析构函数是non-virtual的，除非这个class的base class声明有virtual析构函数。

编译器何时拒绝生出operator=？

一般而言只有当生出的代码合法且有适当机会证明它有意义，编译器生成的copy assignment操作符其行为与copy构造函数如出一辙。万一两个条件有一个不符合，编译器就拒绝为class生产operator=。

       情况1：当类含reference成员时，编译器将拒绝为其生成copy assignment操作符。

       情况2：当类含const成员时，编译器将拒绝为其生成copy assignment操作符。

       情况3：如果某类的base classes将copy assignment操作符声明为private，编译器将拒绝为其derived classes生成copy assignment操作符。

【要点摘录】C++不允许“让referenct改指向不同的对象”。

请记住：

编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数。

--By Nathan.Yu 2007-11-12--

1 让自己习惯C++(三)

条款04：确定对象被使用前已先被初始化

读取未初始化的值会导致不明确的行为。

最佳的处理方法：永远在使用对象之前先将它初始化。

       对内置类型：手工初始化。

       对自定义类型：确保每个构造函数都将对象的每一个成员初始化。

别混淆了赋值（assignment）和初始化（initialization）。

1、  成员初始化何时发生？

C++规定，对象的成员变量的初始化发生在进入构造函数本体之前。使用member initialization list（成员初值列表）替换在构造函数体中的赋值动作。

2、  为什么使用初始化列表效率较高？

初始化列表避免了先调用成员的default构造函数这一多余的过程。

3、  内置类型成员应选用初始化列表还是赋值进行初始化？

内置类型的“赋值表现像初始化一样好”，但为了一致，最好也通过成员初始列表来初始化内置类型。

【要点摘录】请立下规则：规定总是在初值列表中列出所有成员变量，以免还得记得哪些成员变量（如果它们在初值列表中被遗漏的话）可以无需初值。

4、  何时内置类型成员变量必须使用初值列表初始化？

当它们是const或references时，它们就一定需要初值，不能被赋值。

5、  有多个构造函数，且成员较多时怎么办？如何初始化？

在这种情况下，可以合理的在初值列表中遗漏那些“赋值表现像初始化一样好”对成员，改用它们的赋值操作，并将那些赋值操作移往某个函数（通常是private），共所有构造函数调用。这种做法在“成员变量的初值系由文件或数据库读入”时特别有用。

6、  成员的初始化顺序如何?

C++有十分固定的初始化次序：base classes更早于其derived classes被初始化，而classes当成员变量总是以其声明的次序初始化。

【要点摘录】为避免你或你的检阅者迷惑，并避免某些可能存在的晦涩的错误，当你在初始化列表中以声明的次序初始化各成员。

7、  static对象有哪些？

所谓static对象，其寿命从被构造出来直到程序结束为止，因此stack和heap对象都被排除。这种对象包括：global对象；定义于namespace作用域内的对象；在classes内、在函数内、以及在file作用域内被声明为static的对象。其中，函数中的static对象称为local static对象，其他static对象称为non-local static对象。static对象的析构函数会在main函数结束时被自动调用。

8、  什么是编译单元？

所谓编译单元(translation unit)，是指产出单一目标文件的那些源码。基本上它是单一源码文件加上其所含入的头文件。

【要点摘录】C++对“定义于不同编译单元内的non-local static对象”的初始化次序并无明确定义。

【要点摘录】C++保证，函数内的local static对象在“该函数被调用期间”“首次遇上该对象之定义式”时被初始化。

请记住：

1、为内置型对象进行手工初始化，因为C++不保证初始化它们。

2、构造函数最好使用成员初值列表，而不要在构造函数体内使用赋值操作。初值列表列出的成员变量，其排列次序该和它们在class中的声明次序相同。

3、为免除“跨编译单元之初始化次序”问题，请以local static对象替换non-local static 对象。（使用reference-returning函数）。

--By Nathan.Yu 2007-11-11--

1 让自己习惯C++(二)

条款03：尽可能使用const

const允许你指定一个语义约束（也就是指定一个“不该被改动”的对象），而编译器会强制实施这项约束。

const的用处：修饰global或namespace作用域中的常量；或修饰文件、函数、或区块作用域中被声明为static的对象；也可以修饰classes内的static和non-static成员变量；修饰指针（迭代器）及它们所指定对象等。而最具威力的用法是在函数声明中，在一个函数声明内，const可以和函数返回值、参数、函数自身（成员函数）产生关联。

const与指针：如果关键字const出现在星号左边（类型之前或之后一样），表示被指物是常量；如果出现在星号右边，表示指针本身是常量；如果出现在星号两边，表示被指物和指针都是常量。

const与迭代器：声明迭代器为const（即const ..::iterator xóT* const x）表示这个迭代器不能指向不同的东西，但它指向的东西是可以改动的。如果希望迭代器所指定东西不可被改动,可使用const_iterator;

【要点摘录】一个“良好的用户自定义类型”的特征是它们避免无端的与内置类型不兼容。

const成员函数：将const实施与成员函数的目的，是为了确认该成员函数可作用于const对象（当然也可作用于非const对象），而非const成员函数则只能作用与非const对象。

const成员函数使“操作const对象”成为可能，这对编写高效代码是个关键。因为改善C++程序效率的一个根本方法是以pass-by-referenct-to-const方式传递对象，而此技术可行的前提是我们有const成员函数可用来处理取得（并经修饰而成）的const对象。

<在普通的非const成员函数中，this指针的类型是T* const this的，可以改变所指物，但不能改变指针本身；在const成员函数中，this指针的类型是const T* const this的，二者都不能改变>

【要点摘录】两个成员函数如果只是常量性不同，可以被重载。这实在是一个重要的C++特性。

【要点摘录】如果函数的返回类型是个内置类型，那么改动函数返回值从来就是不合法的。如：int f(); f()=1;是不合法的！

关于const成员函数的两个学派：bitwise constness(又称physical constness)和logical constness

mutable（可变的）关键字：释放掉non-static成员变量的bitwise constness约束，使在成员函数中可修改const成员的值。

在const和non-const成员函数中避免重复：

允许non-const调用const，而不允许const调用non-const。因为const成员函数调用non-const成员函数时，对象有可能被改动。const调用non-const时，必须用const_cast将*this上的const性质去掉才能调用，这是不安全的做法。

请记住：

1、将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

2、编译器强制实施bitwise constness，但你编写程序时应该使用“概念上的常量性”（conceptual constness）。

3、当const和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。

--By Nathan.Yu 2007-11-10--

1 让自己习惯C++

条款01：视C++为一个语言联邦

C++最初的名称是：C with Classes

今天的C++是：多重泛型编程语言(multiparadigm programming language)，同时支持过程形式（procedural）、面向对象形式（object-oriented）、函数形式（functional）、泛型形式（generic）、元编程形式（metaprogramming）的语言。

将C++视为一个由相关语言组成的联邦而非单一语言。在某个次语言（sublanguage）中，各种守则与通例都倾向简单、直观易懂、并且容易记住。然而当从一个次语言移往另一个次语言，守则可能改变。

认识C++主要的次语言：

C：C++以C为基础。区块（blocks）、语句（statements）、预处理（preprocessor）、内置数据类型（built-in data types）、数组（arrays）、指针（pointers）等都来自C。

C的局限：没有模板（templates）、没有异常（exceptions）、没有重载（overloading）…….

Object-Oriented C++：classes(包括构造函数和析构函数)、封装（encapsulation）、继承（inheritance）、多态（polymorphism）、virtual函数（动态绑定）……

是面向对象设计之古典守则在C++上的最直接实施。

Template C++：即C++的泛型编程（generic programming）部分。由于templates的强大威力，带来了崭新的编程泛型，即所谓的模板元编程（template metaprogramming，TMP）。

STL：是一个template程序库。STL有自己特殊的办事方式，当你伙同STL一起工作，必须遵守它的规约。

当你从一个次语言切换到另一个时，相应的高效编程守则要求你改变策略，以参数传递方式为例：对内置类型而言pass-by-value通常比pass-by-reference高效，但当你从C part of C++移往Object-Oriented C++，由于用户自定义构造函数和析构函数的存在，pass-by-reference-to-const往往更好。运用Template C++时更是如此，因为彼时你甚至不知道所处理的对象的类型。然而在STL中，迭代器和函数对象都是在c指针之上塑造出来的，所以对STL迭代器和函数对象而言，pass-by-value再次适用（仅仅指迭代器和函数对象）。

请记住：

C++高效编程守则视状况而变化，取决于你使用C++的哪一部分。

条款02：尽量以const，enum，inline替换#define

“宁以编译器替换预处理器”，因为或许#define不被视为语言的一部分。当你：

#define ASPECT_RATIO 1.653

记号名ASPECT_RATIO也许从没被编译器看见；也许在编译器开始处理源代码之前它就被预处理器移走了。于是记号ASPECT_RATIO有可能没有进入记号表（symbol table）内。因此不能用此记号来获得编译错误信息。

解决之道：用一个常量替换宏（#define），

const double AspectRatio = 1.653;

常量定义通常放在头文件内，以便不同的源码含入。因此有必要将指针（而不是指针所指之物）声明为const：

const/*需要吗？*/ char* const/*防止在不同的地方改变authorName 的指向吧?!*/ authorName = “Scott Meyers”;

Class 专属常量：为了将常量的作用域(scope)限制于class内，你必须让它成为class第一个成员(member)；而为确保此常量至多只有一份实体，必须让它成为一个static成员：

class GamePlayer{

private:

       static const int NumTurns = 5;  //常量声明式，注意是声明！！！！！不是定义

/*

通常C++要求你对所使用的任何东西提供一个定义式，但如果它是个class专属常量，又是static，又是整数类型（ints、chars、bools），则可特殊处理：即只要不取他们的地址，可以只声明而不定义便可使用。但如果你取某个class专属常量的地址，或你使用的编译器（不标准的）坚持要一个定义式，则必须提供定义式如下：

const int GamePlayer::NumTurns; //没有赋值，因为声明式已经为其设立初值5，故此略去

注意：这个定义式应放进class的实现文件，而非头文件。

*/

       int scores[NumTurns]; //常量的使用

};

（无法用#define创建一个class专属常量！更别提像const成员那样可以被封装了！）

旧时的编译器也许不支持上述语法：它们不允许static成员在声明式上获得初值。此外“in-class初值设定”也只允许对整数常量进行。若此，则可：

class CostEstimate{

private:

       static const double FudgeFactor;//声明，位于头文件

       …….

};

const double CostEstimate:: FudgeFactor = 1.35;//定义，位于实现文件

此外，可改用“the enum hack”补偿做法。其理论基础是：“一个属于枚举类型的数值可权充ints被使用”，于是：

class GamePlayer{

private:

       enum { NumTurns = 5};

       int scores[NumTurns];

};

enum hack的行为像define而不像const，例如，取一个const的地址是合法的，而取enum和define对地址都是不合法的。虽然，优秀的编译器不会为“整数型const对象”设定另外的存储空间（除非你创建了一个pointer或reference指向该对象），不够优秀的编译器却可能如此，而这可能不是你想要的。Enums和#defines一样绝不会导致非必要的内存分配。

另外，enum hack还是TMP对基础技术。

template inline函数：可以获得宏带来的效率以及一般函数的所有可预料行为和类型安全。

请记住：

1、对于单纯常量，最好以const对象或enums替换#defines

2、对于形似函数的宏，最好改用inline函数替换#defines

--By Nathan.Yu 2007-11-10--

0 导读

1、设计策略

如何在两个不同的做法中择一完成某项任务，如

该选择inheritance(继承)还是templates（模板）？该选择public继承还是private继承？该选择private继承还是composition（复合）？该选择member函数还是non-member函数？该选择pass-by-value还是pass-by-reference？….

什么是assignment操作符的适当返回类型?何时该令析构函数为virtual?当operator new无法找到足够的内存时该如何行事？…..

2、术语

声明式（declaration）：告诉编译器某个东西的名称和类型，但略去细节。如

extern int x;

std::size_t numDigits(int number);

/*

std::size_t,表示类型size_t位于命名空间std内。而继承自c动符号（如size_t）有可能存在于global作用域或std内，甚至两个兼具，取决于哪个头文件被含入(#included).

每个函数的声明揭示其签名式(signature)，也就是参数类型和返回类型。如，numDigits函数的签名是std::size_t (int)。但c++对签名的官方定义并不包含返回类型。

*/

class Widget;

template<typename T> class GraphNode;

定义式(definition)：告诉编译器声明式所遗漏的细节。对对象而言，定义式是编译器对此对象拨发内存的地点；对function或function template而言，定义式提供了代码本体；对class或class template而言，定义式列出它们的成员。

初始化(Initialization)：“给予对象初值”的过程。对用户自定义的类型的对象而言，初始化由构造函数执行。

default构造函数：是一个可被调用而不带任何实参的类成员函数。这样的构造函数要不没有参数，要不就是每个参数都有缺省值。

explicit构造函数：可以阻止它们被用来执行隐式类型转换(implicit type conversions)，但可显式转换(explicit type conversions)。被声明为explicit第构造函数通常比其non-explicit兄弟更受欢迎，因为他禁止编译器执行预期（往往是不期望）的类型转换。把构造函数声明为explicit！

copy构造函数：以同型对象初始化新自我对象。

copy assignment操作符：从一个同型对象中拷贝其值到另一个自我对象。

pass-by-value：意味“调用copy构造函数”。以by-value传递用户自定义类型通常是个坏主意，pass-by-reference-to-const往往是比较好的选择。

STL：标准模板库(Standard Template Library)，包含容器（如vector， list， set， map等等）、迭代器（如vector<int>::iterator, set<string>::const_iterator等等）、算法（如for_each， find， sort等等）机能。

函数对象（function objects）：行为像函数的对象，这样的对象来自于重载operator()(function call 操作符)的classes。

行为没有定义：你无法稳定预估运行期会发生什么事。如

int* p = 0;

std::cout << *p; //对一个null指针取值会导致不明确行为。

接口（interface）：Java和.NET语言都提供Interfaces为语言元素，但c++没有。

客户（client）：某人或某物，他(或它)使用你的代码（通常是一些接口）。一般指程序员。

3、TR1和Boost

TR1(Technical Report 1)：一份规范，描述加入C++标准程序库的诸多新机能。这些机能以新的class templates 和 function templates形式体现，有hash tables, reference-counting smart pointers, regular expressions等，所有TR1组件都被置于命名空间tr1中，tr1则位于std内（即std::tr1）。

Boost是个组织，提供可移植、同僚复审、源码开放的c++程序库。大多数TR1机能是以Boost的工作为基础的。Boost提供比TR1更多的东西。

TR1与Boost的关系：