Effective C++改善程序与设计的55个具体做法（第三版）(个人笔记）

Effective C++改善程序与设计的55个具体做法（第三版）

1、       让自己习惯C++

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

1、  C，C++的基础。局限：没有模板(template)、没有异常(exceptions)、没有重载…

2、  Objective-Oriented C++。封装、继承、多态、虚函数。

3、  Template C++。其中MTP，模板元编程。

4、  STL。容器、迭代器、算法、函数对象。

条款02：尽量使用const、enum、inline替代#define

1、 enum{NumTurn = 5}。如果不想别人获得一个指针或引用指向你的某个整数常量，enum可以帮助实现这个约束。

2、 对于单纯常量，最好以const对象或enums替代#define

3、 对于函数的宏，最好改用inline函数替代#define

4、 class中的static const 常数成员，类内声明，类外定义。

5、 预处理器中，#include仍然是必需品，#ifdef/#ifndef也继续扮演控制编译的重要角色。

#ifndef可以防止重复定义。

条款03：尽可能使用const

1、 const出现在星号（*）左边，表示所指物是常量；const出现在星号右边，表示指针本身为常量。Const_iterator 所指物不可变。

2、 将const实施于成员函数的目的，是为了确定该成员函数可作用于const对象身上。Const对象只能调用const成员函数。

3、 关键字Mutable可用于修饰成员变量，使成员在const成员函数中可变。

4、 在重载的const和non-const成员函数中，可以在non-const成员函数中调用const版本，避免代码重复。

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

1、 C++规定，对象的成员变量的初始化动作发生在进入构造函数本体之前。

2、 Static变量（全局和局部）在main函数结束时才调用其析构函数。

3、 为免除“跨编译单元之初始化次序”问题，请以local static对象替代non-local static对象。也就是把non-local static 放入到函数内，使函数返回指向这个local static的引用。这个手法(Singleton)的基础在于：c++保证，函数内的local static对象会在“该函数被调用期间”“首次遇上该对象之定义式”时被初始化。

2、       构造/析构/赋值运算

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

1、 默认构造函数、复制构造函数、赋值操作符、析构函数（非virtual）。

2、 C++不允许“让reference改指向不同对象”。

3、 如果某个base classes将copy assignment声明为private，编译器将拒绝为其derived classes生成copy assignment操作符。

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

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

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

1、 C++明白指出，当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义----实际执行时通常发生的是对象的derived成分没被销毁。

2、 析构函数被定义为pure virtual函数时，需要为这个pure virtual析构函数提供一份定义。

3、 构造函数，先构造基类；析构函数，先析构派生类。

4、 带多态性质的基类应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。

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

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

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

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

1、 因为无法使用virtual函数从base class向下调用，在构造期间，可以借助“令derived classes 将必要的构造信息向上传递至base class构造函数”。

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

1、 为了实现“连锁”赋值“，赋值操作符必须返回一个reference指向操作符的左侧实参。

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

1、 可以使用“证同测试“（if判断）达到自我复制的目的，但是不具备异常安全。

2、 可以精心周到的对语句手工排序（先保存旧值）、以及copy-and-swap达到异常安全。

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

1、 当你编写一个copying函数，请确保（1）复制所有local成员变量，（2）调用所有base classes内的适当的copying函数（初始化列表中）。

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

3、       资源管理

条款13：以对象管理资源

1、 把资源放进对象内，我们便可以依赖C++的“析构函数自动调用机制”确保资源被释放。

2、 为防止资源泄露，请使用RAII对象，即在构造函数中获得资源并在析构函数中释放资源。

3、 两个常用的RAII classes分别是std::tr1::shared_ptr(C++11std::shared_ptr)和std::auto_ptr和C++11std::weak_ptr（为了解决std::shared_ptr环形引用问题）。

条款14：在资源管理类中小心copying行为

1、 如果复制动作对RAII class并不合理，应该禁止复制。可以将copying操作声明为private而不定义，也可以继承 Uncopyable class。

2、 对底层资源祭出“引用计数法”。可以借助std::shared_ptr实现。它允许我们指定所谓的“删除器”，函数或函数对象。

3、 其他还有：复制底部资源（深度拷贝）、转移底部资源的拥有权（std::auto_ptr）。

条款15：在资源管理类中提供对原始资源的访问

1、 有时候需要将RAII class对象转换为其所含之原始资源。有两个做法可以达成目标：显式转换和隐式转换。

2、 显示转换RAII class提供一个get成员函数。

3、 隐式转换：1）RAII对象重载（operator ->和operator*），它们允许隐式转换为底层原始指针。1）定义隐式转换函数（operator 转成类型（）const）。隐式转换可能存在隐患。

条款16：成对使用new和delete时要采取相同形式

1、 如果你在new表达式中使用[]，必须在相应的delete表达式中也使用[]。如果你在new表达式中不是用[]，一定不要在相应的delete表达式中使用。

条款17：以独立语句将newed对象置入智能指针

1、 通俗的说，就是先把newed对象放入智能指针，然后再把它作为实参传递给形参。

4、       设计与声明

条款18：让接口容易被正确使用，不易被误用

1、 明智而审慎地导入新类型对预防“接口被误用”有神奇疗效。

2、 Std::shared_ptr提供的某个构造函数接受两个参数：一个是被管理的指针，令一个是引用次数变成0时将会被调用的“删除器”。

3、 “促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容。

4、 “防止误用”的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。

条款19：设计class犹如设计type

1、 如果你希望允许类型T1之物被隐式转换为类型T2之物，就必须在class T1内写一个类型转换函数（operator T2）或在class T2内写一个 non-explicit-one-argument的构造函数。

2、 Copying构造函数用来定义一个type的pass-by-value该如何实现。

条款20：宁以pass-by-reference-to-const替换pass-by-value

1、 尽量以pass-by-reference-to-const替代pass-by-value。前者通常比较高效，并可避免切割问题。

2、 对于内置类型，以及STL的迭代器和函数对象，使用pass-by-value往往比较适当。

条款21：必须返回对象时，别妄想返回其reference

1、 reference只是一个名称，代表某个既有对象，也就说这个对象早就存在了。在使用这个reference时，这个对象也要存在。

2、 一个“必须返回新对象”的函数的正确写法是：就是让那个函数返回一个新对象。

3、 绝不要：1）返回pointer或reference指向一个local stack对象；2）返回reference指向一个heap-allocated对象；3）返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。

条款22：将成员变量声明为private

1、 切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺条件约束获得保证，并提供class作者以充分的实现弹性。

2、 Protected并不比public更具封装性。

条款23：宁以non-member、non-friend替换member函数

1、  “封装”使我们能够改变事物而只影响有限客户。

2、  宁以non-member、non-friend替换member函数。这样做可以增加封装性、包裹弹性和机能扩充性。

条款24：若所有参数皆需类型转换，请为此采用non-member函数

1、 只有当参数被列于参数列内，这个参数才是隐式类型转换的合格参与者。

2、 如果你需要为某个函数的所有参数（包括被this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。

条款25：考虑写出一个不抛出异常的swap函数

1、 当std：：swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。

2、 如果你提供了member swap，也该提供一个non-member swap用来调用前者。对于class（而非template），也请特化std：：swap。

3、 调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”。

4、 为“用户定义类型”进行std template全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。

5、 C++只允许对class template偏特化，在function template身上偏特化是行不通的（一般通过重载版本实现）。

5、       实现

条款26：尽可能延后变量定义式的出现时间

1、 尽可能延后变量定义式的出现。这样做可增加程序的清晰度并改善程序效率。

条款27：尽量少做转型动作

1、 四种转型：const_cast用于将对象的常量性转除，也就是const对象转为non-const对象；dynamic_const主要执行“安全向下转型”，也就是用来决定某对象是否归属继承体系中的某个类型，效率低下；reinterpret_const意图执行低级转型，例如，将int*转为int，实际动作可能取决于编译器，不可移植；static_const用来强迫隐式转换。

2、 之所以需要dynamic_cast，通常是因为你想在一个你认为derived class对象身上执行derived class操作函数，但你手上却只有一个“指向base”的pointer或reference，你只能靠它们来处理对象。有两个一般性做法可以避免这个问题。

3、 第一，使用容器并在其中存储直接指向derived class对象的指针。这个做法使你无法在同一容器内存储指针“指向所有可能之各种派生类”。可能需要多个容器存储不同的派生类指针。

4、 另一种做法就是在bass class内提供virtual函数，也就是通过多态替代dynamic_cast。

5、 尽量避免转型，如果避无可避，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需将转型放进他们自己的代码内。

条款28：避免返回handles指向对象内部成分

1、 handles是指引用 、指针和迭代器。

2、 返回一个“代表对象内部数据”的handle，随之而来的便是“降低对象封装性”的风险。还可能导致“虽然调用const成员函数却造成对象状态被更改”。“内部”是指class的private部分，成员变量和private成员函数。

3、 避免返回handles指向对象内部。遵守这个条件可增加封装性，帮助const成员函数的行为像个const，并将发生“虚吊handles”的可能性降至最低。

条款29：为“异常安全”而努力是值得的

1、 异常安全函数即使发生异常也不会泄露资源或允许任何数据结构败坏。这样的函数区分分为三种可能的保证：基本型（有效状态）、强烈型（要么全变要么不变）、不抛异常型。

2、 “强烈保证”往往能够以copy-and-swap实现出来。

条款30：透彻了解inlining的里里外外

1、 使用inline函数可以“免除函数调用成本”，编译器最优化机制通常被设计用来浓缩那些“不含函数调用”的代码，inline函数有机会被优化。

2、 Inline只是对编译器的一个申请，不是强制命令。这项申请可以明确提出（inline +定义式），也可以隐喻的提出（类内定义的成员函数和friend函数）。

3、 Inline是个申请，编译器可以加以忽略，一般以下函数会被拒绝inline：函数太过复杂、virtual函数、构造和析构函数、通过函数指针调用的函数。

4、 Virtual函数不能为inline函数是因为：inline一般发生在编译过程，意味着“执行前，先将调用动作替换为被调用函数的本体（而此时virtual函数还不知道应该调用哪一个）；virtual意味”等到运行期才确定调用哪个函数“。

5、 Inline函数无法随着程序库（静止连接）的升级而升级，需要重新编译。大部分调试器面对inline函数都束手无策。

6、 将inlining限制在小型、被频繁调用的函数身上。

条款31：将文件间的编译依存关系降至最低

1、 支持“编译依存最小化“的一般构想是：相依于声明式，不要相依于定义式。基于此构想的两个手段是Handle classes和Interface classes。

2、 Handle class的设计称为pimpl idiom。Main class内只含一个指针成员，指向实现类。Main class和实现类有着完全相同的成员函数，两者接口完全相同。

3、 Interface class 借助abstract base（抽象基类）实现。

4、 Interface class的客户必须有办法为这种class创建新对象。他们通常调用一个特殊函数，该函数扮演“真正将被具现化“的那个derived classes的构造函数角色，通常被称为factory（工厂）函数或virtual构造函数。它们返回指针（或智能指针）指向动态分配所得对象。通常被声明为static。

5、 一个更现实的create（工厂函数或virtual构造函数）实现代码会创建不同类型的derived class对象，取决于额外参数值、读自文件或数据库的数据、环境变量等等。

6、       继承与面向对象设计

条款32：确定你的public继承塑模出is-a关系

1、  “public继承意味is-a。适用于base classes身上的每一件事情一定也适用于derived classes身上，每一个derived class对象也都是一个base class对象。

条款33：避免遮掩继承而来的名称

1、 在继承体系中，derived class作用域被嵌套在base class作用域内。

2、 Derived classes内的名称会遮掩base classes内的名称。在public继承下从来没有人希望如此。

3、 为了让被遮掩的名称再见天日，可使用using声明式（全部）或转交函数（可部分）。

条款34：区分接口继承和实现继承

1、 pure virtual函数：必须被任何”继承了它们“的具象类重新声明，它们在抽象class中通常没有定义。声明一个pure virtual函数的目的是为了让derived classes只继承函数接口。

2、 令人意外的是，我们竟然可以为pure virtual函数提供定义，但调用它的唯一途径是“调用时明确指出其class名称”。

3、 声明为impure virtual函数的目的，是让derived classes继承该函数的接口和缺省实现。

4、 声明non-virtual函数的目的是为了令derived classes继承函数的接口及一份强制实现。

条款35：考虑virtual函数以外的其他选择

1、 借助Non-Virtual Interface手法实现Template Method。令客户通过public non-virtual成员函数间接调用private virtual函数。在NVI手法下没有必要让virtual函数一定得是private。NVI的优点，在调用virtual函数之前和之后可以做一些事情，比如互斥器、日志、验证条件等。

2、 借助Function Pointers实现Strategy模式。函数指针作为class的成员。好处：同一人物类型之不同实体可以有不同的健康计算函数；某种已知任务之健康指数计算函数可以在运行期变更。

3、 借助std::function完成Strategy模式。以std：：function替代函数指针，可以把它看成一种指向函数的泛化指针。Std::bind返回附带参数的函数。

4、 古典Strategy模式。将健康函数做成一个分离的继承体系中的virtual成员函数。角色类有一个成员指向计算健康函数的基类的指针。将继承体系内的virtual函数替换为另一个继承体系内的virtual函数。

条款36：绝不重新定义继承而来的non-virtual函数

条款37：绝不重新定义继承而来的缺省参数值

1、 virtual函数是动态绑定，而缺省参数值却是静态绑定。也就是说，可能调用一个定义于derivedclass内的virtual函数的同时，却使用base class为它所指定的缺省参数值。

2、 如果在base class中提供了参数缺省值，在derived class不要重新定义。当用基类指针指向派生类对象时，会继承基类的参数缺省值，而当直接定义派生类对象时，并不会继承基类的参数缺省值。

条款38：通过复合塑模出has-a或“根据某物实现出“

1、 复合是类型之间的一种关系，当某种类型的对象内含它种类型的对象，便是这种关系。

2、 复合的意义和public继承完全不同，它表示has-a关系或is-implemented-in-terms-of（根据某物实现出）关系。

条款39：明智审慎地使用private继承

1、 在public继承中derived class可以暗自转为base class，而private继承不可以。Private继承意味这“implemented-in-terms-of（根据某物实现出），是一种实现技术。Private继承意味只有实现部分被继承，接口部分省略。

2、 尽可能使用复合，必要时才使用private继承。必要时：当derived class需要访问protected base class的成员，或需要重新定义继承而来的virtual函数。

3、 和复合不同，private继承可以造成empty base最优化。这对立志于“对象尺寸最小化“的程序库开发者而言，可能很重要。

条款40：明智而审慎地使用多重继承

1、 C++解析重载函数调用：在看到是否有个函数可取之前，C++首先确认这个函数对此调用直言是最佳匹配。找出最佳匹配函数后才检验其可取用性。

2、 多重继承比单一继承复杂。它可能导致新的歧义性（比如多个base class拥有相同的函数），以及对virtual继承的需要（钻石型）。

3、 Virtual继承会增加大小、速度、初始化(most derived class负责)复杂性等成本。如果virtual base class不带任何数据，将是最具实用价值的情况。

4、 虚表是属于类的，而不是属于某个具体的对象，一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。为了指定对象的虚表，对象内部包含一个虚表的指针，来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针，编译器在类中添加了一个指针，*__vptr，用来指向虚表。这样，当类的对象在创建时便拥有了这个指针，且这个指针的值会自动被设置为指向类的虚表。

7、       模板与泛型编程

条款41：了解隐式接口和编译期多态

1、 Classes和template都支持接口和多态

2、 对classes而言接口是显式的，以函数签名为中心。多态则是通过virtual函数发生在运行期。

3、 对template参数而言，接口是隐式的，基于有效表达式。多态则是通过template具现化和函数重载解析发生于编译期。

条款42：了解typename的双重意义

1、 如果解析器在template中遭遇一个嵌套从属名称（T::type），它便假设这个名称不是类型，除非你告诉它是。（typename前缀）。

2、 一般性规则（有特例）：任何时候当你想要在template中指涉一个嵌套从属类型名称，就必须在紧邻它的前一个位置放上关键字typename。

3、 特例：typename不出现在base classes list（继承列表）内的嵌套从属类型名称之前；typename不出现在member initialization list（成员初始列表）中。

条款43：学习处理模板基类中的名称

1、 在模板继承中，默认情况下，编译器不进入base class作用域中寻找。这是因为，base class template有可能被特化，那个特化版本可能不提供和一般template相同的接口。

2、 为了进入模板基类寻找，1）在base class函数调用动作之前加上“this->“；2）using声明式；3）作用域base：：（不足：关闭了virtual绑定行为）。

3、 从名称可视点的角度出发，上述每一种解法做的事情都相同：对编译器承诺“base class template的任何特化版本都支持其一般（泛化）版本所提供的接口“。

条款44：将与参数无关的代码抽离template

1、 因非类型模板参数造成的代码膨胀，往往可以消除，做法是以函数参数或class成员变量替换template参数。

条款45：运用成员函数模板接受所有兼容类型

1、 同一个template的不同具现体之间并不存在什么与生俱来的固有关系（比如继承）。编译器视SmartPtr和SmartPtr为完全不同的classes。

2、 为了实现同一template的不同具现体之间的隐式转换，可以使用copy构造函数模板实现。可以基于原始的隐式转换，来对隐式转换行为筛选。

3、 在同一template的不同具现体中，请使用成员函数模板生成“可接受所有兼容类型”函数。

4、 如果你声明member template用于“泛型copy构造”或“泛型assignment操作”，你还需要声明正常的copy构造函数和copy assignment操作符。

条款46：需要类型转换时请为模板定义非成员函数（inline friend函数）

1、 在template实参推导过程中从不将隐式类型转换函数纳入考虑。

2、 为了具现出模板类中可以隐式转换的函数，我们把它定义为inline friend函数。这样，class templates并不依赖template实参推导，编译器在class Ration具现化时得到了T和相关函数。

3、 当我们编写一个class template，而它所提供的“与此template相关的”函数支持“所有参数之隐式类型转换”时，将那些函数定义为“class template内部的inline friend函数。

条款47：请使用traits classes表现类型信息

1、 五种迭代器：input迭代器、output迭代器、forward迭代器（继承自input迭代器）（可以读写多次）、bidirectional迭代器、random access迭代器。

2、 Traits classes使得“类型相关信息“在编译期可用。他们以templates和templates特化”完成实现。

3、 整合重载技术后，traits classes有可能在编译期对类型执行if…else测试。

4、 如何使用traits class：1）建立一组重载函数（身份像劳工）或函数模板，彼此之间的差异只在于各自的traits参数。令每个函数实现码与其接受之traits信息相应和；2）建立一个控制函数（身份像工头）或函数模板，它调用上述那些“劳工函数”并传递traitsclass所提供的信息。

条款48：认识template元编程

1、 TMP的两个伟大效力。1）使某些事情更容易。2）由于template metaprograms执行于C++编译期，因此将工作从运行期转移到编译期。这使某些错误原本通常在运行期才能检测到，现在可在编译期找出来。另一个结果是，使用TMP的C++程序可能在每一方面都更高效：较小的可执行文件、较短的运行期、较小的内存需求。编译时间会变长。

2、 Template meta programing可将工作由运行期移往编译期，因而得以实现早期错误侦测和更高的执行效率。

8、       定制new和delete

条款49：了解new-handler行为

1、 set_new_handler允许客户指定一个函数，在内存分配无法获得满足时被调用。

2、 Nothrow new是一个颇具局限的工具，因为它只适用于内存分配；后继的构造函数调用还是可能抛出异常。

3、 Static成员必须在class定义式之外被定义（除非他们是const而且是整数型）。

4、 C++并不支持class专属的New-handler，但是可以实现。通过1）class中定义static operatornew 和static set_new_handler成员函数，static new-handler成员；2）在std::new-handler资源管理class（用于std::new-handler的设定和还原）。

5、 上述实现方法并不因class的不同而不同。所以，使用模板和继承的方式，使derived classes“设定class专属值new-handler”的能力。继承自base class 模板的每一个derived class拥有实体互异的复件。类型参数T只是用来区分不同的derived class。

条款50：了解new和delete的合理替换时机

1、 替换编译器提供的operator new 或operator delete的最常见的理由：1）用来检测运用上的错误。2）为了强化效能（时间和空间）。3）为了收集使用上的统计数据。

2、 “齐位”是内存分配时需要考虑的技术细节。

条款51：编写new和delete时需固守常规

1、 operator new应该内含一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用new-handler。它也应该有能力处理0bytes申请（转为1byte）。Class专属版本则还应该处理“比正确大小更大的（错误）申请（可能是派生类）（调用全局的：：operator new）。

2、 operator delete应该在收到null指针时不做任何事。Class专属版本还应该处理“比正确大小更大的（错误）申请（调用全局的：：operatordelete）。

条款52：写了placement new也要写placement delete

1、 Widget *pw = new Widget。共有两个函数被调用：一个用来分配内存的operatornew，一个是Widget的默认构造函数。当new正常而默认构造函数抛出异常，客户没有能力规划内存，取消new并恢复旧观的责任落到了C++运行期系统身上。

2、 当你只使用正常形式的new和delete，运行期系统可以找到相应delete版本。然而当你开始声明非正常形式的operator new，也就是有附加参数的operator new，“究竟哪一个delete伴随这个new”的问题便浮现了。

3、 Placement delete只有在“伴随placement new调用而触发的构造函数”出现异常时才被自动调用。对着一个指针施行delete（delete pw）绝不会导致调用placement delete。

4、 当你声明placement new 和placement delete，请确定不要无意识（非故意）地遮掩了它们的正常版本。可以通过继承机制及using声明式取得标准形式。

番外：New和malloc的区别

1、 属性：new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。

2、 参数：使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

3、 返回类型：new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

4、 分配失败：new内存分配失败时，会抛出bad_alloc异常。malloc分配内存失败时返回NULL。

5、 自定义类型：new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

6、 重载：C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。

9、       杂项讨论

条款53：不要轻忽编译器的警告

1、 严肃对待编译器发出的警告信息。努力在你编译器的最高（最严苛）警告级别下争取“无任何警告”的荣誉。

2、 不要过度依赖编译器的警报能力，因为不同的编译器对待事情的态度并不相同。一旦移植到另一个编译器上，你原来依赖的警告信息有可能消息。

条款54：让自己熟悉包括TR1在内的标准程序库

1、 智能指针（std::shared_ptr、std::weak_ptr）、泛化函数指针（如std::function）、std::bind、Hash table（std::unordered_map、std::unordered_set）、正则表达式等。

2、 TR1自身只是一份规划。为了获得TR1提供的好处，你需要一份实物。一个好的实物来源是Boost。

条款55：让自己熟悉Boost

1、 Boost是一个社群，也是一个网站。致力于高质量、源码开放、平台独立、编译器独立、同僚复审的C++程序库开发。Boost在C++标准化过程中扮演深具影响力的角色。

2、 Boost提供许多TR1组件实现品，以及其他许多程序库。