2.1.习惯C++

2.1.1.条款1 视c++为一个语言联邦

四个次语言：
C
Object-Oriented C++
Template C++
STL
1、高效编程守则视状况变化，取决于你是用C++的哪一部分。

如：对于内置类型（C）而言，pass by value通常比pass by reference高效。但对于Object-Oriented C++而言，引用更高效。

2.1.2.条款2 尽量以const、enum、inline替换#define

#define不被视为语言的一部分，宁可以编译器替换预处理器；
#define没有作用域
1、对于单纯常量，最好使用const和enum代替#define。发现问题时无法查看符号表。
2、对于形似函数的宏，最好改用inline函数替换#define。

2.1.3.条款3 尽可能使用const

指针为例：const出现在星号左边，表示被指物是常量，const出现在星号右边，表示指针本身是常量；const出现在左右两边，表示被指物和指针都是常量。
bitwise constness: bitwise constness阵营的人认为，成员函数只有在不更改对象任何成员变量（static除外）时才可以说是const。
logical constness（逻辑常量）
  logical constness阵营的人认为，const虽然不可以在const函数中改变成员变量（static除外）的值，但是允许在某些不知情的情况下改变了类中成员变量的值。
如下

class CTextBlock
{
public:
    //没有改变成员变量的值，但可以在返回之后更改
    char& operator[](std::size_t position)const {
        return pText[position];
    }
private:
    char *pText;
};

请记住：
1、将某些东西声明为const可帮助编译器侦测出错误用法。const通常用于表示函数参数，函数整体。常用与指针和引用。
2、编译器强制实施bitwise constness，但你编写程序时应该使用“概念上的常量性”。

2.1.4.条款4 确认对象被使用前已先被初始化

1、为内置型对象进行手工初始化，因为C++不保证初始化它们。
2、构造函数最好使用成员初值列(member initialization list)，而不要在构造函数本体内使用赋值操作(assignment)，初值列列出的成员变量，其排列次序应该和它们在class中的声明次序相同。
3、为免除“跨编译单元之初始化次序”问题，请以local static对象替换non-local static对象。non-loacl static 变量就是 不受作用域限制且 为static 的对象。 单例使用。

2.2.构造/赋值/析构运算

2.2.1.条款5 c++默默编写并调用的函数管理

1、编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数。当自己定义了这些函数后，编译器不会再自动创建。
2、若不想使用编译器自动生成的函数，就该明确拒绝，= delete.

1、C++11中，当我们定义一个类的成员函数时，如果后面使用"=delete"去修饰，那么就表示这个函数被定义为deleted，也就意味着这个成员函数不能再被调用，否则就会出错。
2、在C++11之前，当我们希望一个类不能被拷贝，就会把构造函数定义为private，但是在C++11里就不需要这样做了，只需要在构造函数后面加上=delete来修饰下就可以了。

2.2.3.条款7 为多态基类声明virtual析构

1、Polymorphic（带多态性质的） base class应该声明一个virtual析构函数。如果class带有任何virtual函数，他就应该拥有一个virtual析构函数。
2、Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性（polymorphically），就不应该声明virtual析构函数。

virtual具有继承性：父类中定义为virtual的函数在子类中重写的函数也自动成为虚函数。
使用场景：第一，修饰父类中的函数 ；第二，修饰继承性（菱形继承）。

override关键字作用：如果派生类在虚函数声明时使用了override描述符，那么该函数必须正确重载其基类中的同名函数，否则代码将无法通过编译。增加了检查性。能加override就加。

操作符重载可以为虚函数。

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

1、析构函数绝对不要吐出异常，如果一个析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。如果吐出异常，大量对象析构造成同一时间大量异常，程序结束或不明确的行为。
2、如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。 如close数据库连接。

2.2.5.条款9 绝不在构造和析构过程中调用virtual函数

1、在基类构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class（比起当前执行构造函数和析构函数的那层）

2.2.3-1 C++构造、析构执行顺序：

1、基类构造函数，按照它们被继承的顺序构造。
2、成员对象的构造函数按照它们声明的顺序构造。因为构造函数中可以使用这个对象中的成员变量，所以调用构造函数的时候，成员变量需要初始化好。
3、类自己的构造函数。
注意：构造函数的执行顺序与初始化列表中的申明顺序无关。初始化列表可以标记是调用哪个构造函数。

析构顺序，是构造顺序的逆：（后创建的可能依赖于前面创建的）
（1）先调用析构函数，再析构类中的成员变量
（2）成员变量的析构顺序与变量在类中声明的顺序是相反的。

2.2.6.条款10 令operator=返回一个引用 to *this

1、请记住：令赋值（assignment）操作符返回一个regerence to this。并且确保当对象自我赋值时operator=有良好行为。
原因如下：T&，返回引用可以提高返回的效率。

a = b； 不是引用时，会多调用一次copy构造函数而已。

Date& operator=(const Date& d)
{
	if (this != &d)		//判断一下是否有给自己赋值
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

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

1、Copying函数应该确保复制“对象内的所有成员变量”及“所有base class成分”。派生和新增成员时。Customer::operator=(rhs);

PriorityCustomer&
PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
    logCall("PriorityCustomer copy assignment operator");
    Customer::operator=(rhs);    //对base class成分进行赋值动作
    priority = rhs.priority;
    return *this;
}

2.3.资源管理

2.3.1.条款13 以RAII对象管理资源（资源管理类）

RAII(Resource Acquisition Is Initialization)：资源获取就是初始化。在构造期间获取资源，在析构期间释放资源
1、为防止资源泄露，请使用RAII，他们在构造函数中获得资源并在析构函数中释放资源。
2、常用的RAII类：shared_ptr和unique_ptr。

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

1、复制RAII对象必须一并复制他所管理的资源，所以资源的copying行为决定RAII对象的copying行为
2、普遍而常见的RAII class copying行为是：抑制copying，实行引用计数法（reference counting）。不过其他行为也都可能被实现。

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

1、APIs往往要求访问原始资源（raw resources），所以每一个RAII class应该提供一个“取得其所管理之资源”
2、对原始资源的访问可能经由显式转换成隐式装换，一般而言显式转换比较安全，隐式转换对客户比较方便

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

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

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

1、以独立语句将newed对象存储于（置入）智能指针内，如果不这样做，一旦异常被抛出，有可能导致难以察觉的资源泄露。

会造成内存泄漏

processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());

可能执行顺序：执行“new Widget”、调用priority、调用tr1::shared_ptr构造函数
万一对priority的调用导致异常，会发生什么事？此情况下“new Widget”返回的指针将会遗失，因为它尚未被置入tr1::shared_ptr内，可能导致内存泄漏。

以下方式不会造成内存泄漏

std::tr1::shared_ptr<Widget>pw(new Widget);  // 在单独语句内以智能指针存储newed所得对象
processWidget(pw, priority());  // 这个调用动作绝不至于造成泄漏

2.4.设计与声明

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

如：工厂模式创建对象返回智能指针而不是指针。
任何接口如果要求客户必须记得做某些事情，就是有不正确的倾向。

2.4.2.条款19 设计class犹如设计type

1、编译器创建的四个函数如何设计。
2、什么样的操作符和函数对此新type而言是合理的？
这个问题的答案决定你将为你的class声明那些函数。其中某些该是member函数，某些则否（条款23,24,26）。
3、你真的需要一个新type吗？
如果只是定义新的derived class以便为既有的class添加机能，那么说不定单纯定义一或多个non-member函数或templates，更能够达到目标

2.4.3.条款20 函数参数宁以pass-by-reference-to-const替换pass-by-value

derived class对象以pass-by-value传递并被视为一个base class对象时，base class对象的copy构造函数被调用，而“造成此对象的行为像个derived class对象”的那些特征性质全被切割了，仅仅留下一个base class对象。如调用的是基类的虚函数。

1、尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题
2、以上规则并不适用于内置类型，以及STL的迭代器和函数对象。因为习惯上，他们被设计为pass-by-value。

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

1、返回引用问题太多。返回堆涉及释放问题，返回栈涉及对象被析构，放回static对象涉及多线程访问。

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

1、切记将成员变量声明为private，这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性
2、protected并不比public更具封装性（继承）。删除protected变量会影响派生类。

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

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

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

1、如果你想为某个函数的所有参数（包括被this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。
如乘法操作符重载。

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

1、当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。
2、如果你提供一个member swap，也该提供一个non-member swap用来调用前者，对于classes（而非templates），也请特化std::swap
3、调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”
用户实现函数模板：写一个function template。

template<typename T>
void doSomething(T& obj1, T& obj2)
{
    usint std::swap;    //令std::swap在此函数内可用
    ...
    swap(obj1, obj2);   //为T型对象调用最佳swap版本
    ...
}

如果没有T专属的swap存在，编译器就会使用std内的swap。

2.5.实现

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

1、尽可能延后变量定义式的出现，尽可能在初始化的时候给初值实参，这样做可增加程序的清晰度并改善程序效率。

2.5.2.条款27 尽量少做转型操作

旧式转型：（T）expression、T(expression)
C++新式转型：
const_cast(expression)：通常被用来将对象的常量性转除（cast away then constness）。它也是唯一有此能力的C++style转型操作符
dynamic_cast(expression)：“安全向下转型”（safe downcasting），也就是用来决定对象是否归属继承体系中的某个类型。它是唯一无法由旧式语法执行的动作，也是唯一可能耗费重大运行成本的转型动作
reinterpret_cast(expression)：意图执行低级转型，实际动作（及结果）可能取决于编译器，这也就表示它不可移植。例如将一个pointer to int转型为int。这一类转型在低级代码以外很少见。
static_cast(expression)：用来强迫隐式转换（implicit conversion），例如将non-const对象转为const对象，或将int转为double，它也可以用来执行上述多种转换的反向转换，例如将void*指针转为typed指针，将pointer-to-base转为pointer-to-derived。但它无法将const转为non-const——这个只有const_cast才办得到

请记住：转型是生成了一个临时对象。
1、如果可以，尽量避免转型，特别是在注重效率的代码中避免dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的替代设计
2、如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需将转型放进他们自己的代码中。
3、宁可使用C+±style（新式）转型，不要使用旧式转型，前者很容易辨识出来，而且也比较有着分门别类的职掌。

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

operator[]这样的函数是个例外。
1、避免返回handles（包括references、指针、迭代器）指向对象内部。遵守这个条款可增加封装性，帮助const成员函数的行为像个const，并降低虚引用的可能性。

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

1.将大多数inlining限制在小型、被频繁调用的函数身上。使代码膨胀问题最小化，使程序提升效率机会最大化。
2.function tempates出现在头文件，但是不一定必须是inline。

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

使用前向声明，而不是包含头文件的方式。

1. 前向声明的类不能定义对象。可以用于定义指向这个类型的指针和引用。
2. 用于申明使用该类型作为形参或返回类型的函数。

2.6.继承与面向对象设计

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

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

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

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

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

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

因为虚函数是个很容易使用的方法，所以很可能没有认真考虑过其他替代方案。需要跳出这个思维。
1、Virtual函数的替代方案包括NVI手法及Strategy设计模式的多种形式。NVI手法自身是一个特殊形式的Template Method设计模式
2、将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员
3、tr1::function对象的行为就像一般函数指针，这样的对象可接纳“与给定之目标签名式（target signature）兼容”的所有可调用物（callable entities）。

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

1、绝对不要重新定义继承而来的non-virtual函数。会打破public继承时is a的关系。

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

1、绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定（使用指针类型函数默认参数），而virtual函数——你唯一应该覆写的东西却是动态绑定

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

1、复合（composition）的意义和public继承完全不同
2、在应用域（application domain），复合意味has-a（有一个）。在实现域（implementation domain），复合意味is-implemented-in-terms-of（根据某物实现出）。

2.6.8.条款39 明智而审慎地使用private继承

1、Private继承意味is-implemented-in-term of（根据某物实现出）。它通常比复合（composition）的级别低。但是当derived class需要访问protected base class的成员，或需要重新定义继承而来的virtual函数时，那么设计是合理的
2、和复合（composition）不同，private继承可以造成empty base最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要

私有继承
1.基类的public 和protected 成员被继承后作为派生类的private成员，派生类的其他成员可以直接访问他们

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

1、多重继承比单一继承复杂，他可能导致新的歧义性，以及对virtual继承的需要
2、virtual继承会增加大小、速度、初始化（及赋值）复杂度等等成本。如果virtual base classes不带任何数据，将是最具实用价值的情况。
3、多重继承的确有正当用途。其中一个情节涉及“public继承某个Interface class”和“private继承某个协助实现的class”的两项组合。

2.7.模板和泛型编程

1、泛型是什么？ 泛型编程是什么？
实质上就是不使用具体数据类型（int、double、float等），而是使用一种通用类型来进行程序设计的方法，泛泛的描述一下数据，这个方法可以大规模的减少程序代码的编写量。
模板函数如下：
其中，T是一个占位符（数据类型占位符），也就是说，将来T这个位置是一个真实的、具体的数据类型。
所以，可以把T这种类型占位符也称为一种数据类型，就叫泛型（generic type）。使用这种类型占位符的编程方式就叫泛型编程。
总之，泛型也是一种数据类型，但它是用来代替所有类型的“通用类型”。

2、什么是模板？
使用了泛型的代码称为模板，由模板生成实际代码的过程称为模板的具体实现。

3、为什么有模板？
目的就是编写一些与类型无关的代码。

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

静态多态
静态多态在编译时就已经确定了函数的调用版本，通常通过模板（Templates）和函数重载（Function Overloading）实现。

1、classes和templates都支持接口（interfaces）和多态（polymorphism）
2、对classes而言接口是显式的（explicit），以函数签名为中心。多态则是通过virtual函数发生于运行期
3、对template参数而言，接口是隐式的（implicit），奠基于有效表达式。多态则是通过template具现化和函数重载解析（function overloading resolution）发生于编译期

2.7.2.条款42 了解typename的双重意义

1、声明template参数时，前缀关键字class和typename可互换
2、请使用关键字typename标识符嵌套从属类型名称；但不得在base class lists（基类列）或member initialization list（成员初值列）内以它作为base class修饰符。

ps,如果编译器在template中遭遇一个嵌套从属名称，它便假设这名称不是一个类型，除非你告诉它是。

2.7.3.条款43 学习处理模板化基类内的名称

1、可在derived class templates内通过“this->”指涉base class templates内的成员名称，或籍由一个明白写出的“base class资格修饰符”完成。

ps，模板化基类被具体化前，不知道里面有什么函数。

2.7.4.条款44 将与参数无关的代码抽离templates

1、Templates生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数产生相依关系
2、因非类型模板参数（non-type template parameters）而造成的代码膨胀往往可以消除，做法是以函数参数或class成员变量替换template参数
3、因类型参数而造成代码膨胀，往往可降低，做法是让带有完全相同二进制表述（binary representations）的具现类型（instantiation types）共享实现码。如使用void *指针而不是具体类型的指针T *。

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

1、请使用member function templates（成员函数模板）生成“可接受所有兼容类型”的函数
2、如果你声明member templates用于“泛化copy构造”或“泛化assignment操作”，你还是需要声明正常的copy构造函数和copy assignment操作符。

2.7.6.条款46 需要类型转换时请为模板定义非成员函数

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

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

1、Traits class使得“类型相关信息”在编译期可用。它们以templates和“templates特化”完成实现
2、整合重载技术（overloading）后，traits classes有可能在编译期对类型执行if…else测试。

如何设计和实现一个traits class：
1、确认若干你希望将来可取得的类型相关信息。例如对迭代器而言，我们希望将来可取得其分类
2、为该信息选择一个名称（例如iterator_category）
3、提供一个template和一组特化版本（例如稍早说的iterator_traits）,内含你希望支持的类型相关信息

2.7.8.条款48 认识template元编程

1、Template metaprogramming（TMP，模板元编程）可将工作有运行期移往编译期，因而得以实现早期错误侦测和更高的执行效率
2、TMP可被用来生成“基于政策选择组合”（base on combinations of policy choices）的客户定制代码，也可用来避免生成某些特殊类型并不适合的代码。与观察者、访问者等设计模式结合。

2.8.定制new和delete

2.8.1.条款49 了解new-handler的行为

1、set_new_handler允许客户指定一个函数，在内存分配无法获得满足时被调用
2、Nothrow new是一个颇为局限的工具，因为它只适用于内存分配；后继的构造函数调用还是可能抛出异常

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

1、有许多理由需要写个自定的new和delete，包括改善效能、对heap运用错误进行调试、收集heap使用信息

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

1、operator new应该内含一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用new-handler。它也应该有能力处理0byte申请。Class专属版本则还应该处理“比正确大小更大的（错误）申请”（继承）
2、Operator delete应该在收到null指针时不做任何事。Class专属版本则还应该处理“比正确大小更大的（错误）申请”（继承）

2.8.4.条款52 写了placement new也要写placement delete

1、当你写一个placement operator new，请确认也写出了对应的placement operator delete。如果没有那么做，你的程序可能会发生隐微而时断时续的内存泄露
2、当你声明了placement new和placement delete，请确定不要无意识（非故意）地遮掩了它们的正常版本

ps, placement operator new指的是参数除了size_t还有其他的。

2.9.杂项讨论

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

1、严肃对待编译器发出的警告信息，努力在你的编译器的最高（最严苛）警告级别下争取“无任何警告”的荣誉
2、不要过度倚赖编译器的报警能力，因为不同的编译器对待事情的态度并不相同。一旦移植到另一个编译器上，你原本倚赖的警告信息有可能消失

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

1、C++标准程序库的主要机能由STL、iostream、locales组成，并包含C99标准程序库
TR1添加了智能指针（例如tr1：：shared_ptr）、一般化函数指针（tr1：：function）、hash-based容器、正则表达式（regular expressions）以及另外10个组件的支持
2、TR1自身只是一份规范。为获得TR1提供的好处，你需要一份实物。一个好的实物来源是Boost

2.9.3.条款55 让自己熟悉Boost

1、Boost是一个社群，也是一个网站。致力于免费、源码开放、同僚复审的C++程序库开发。Boost在C++标准化过程中扮演深具影响力的角色
2、Boost提供许多TR1组件实现品，以及其他许多程序库。

原文链接：https://blog.csdn.net/weixin_45758146/article/details/107028176
原文链接：https://blog.csdn.net/sinat_40658206/article/details/123347821