Effective C++ 学习（1）

最新推荐文章于 2022-12-14 19:01:36 发布

u_hcy2000

最新推荐文章于 2022-12-14 19:01:36 发布

阅读量438

点赞数

分类专栏： # C++ 文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/u_hcy2000/article/details/122162663

版权

C++ 专栏收录该内容

22 篇文章 4 订阅

订阅专栏

1 C++的联邦大厦

C基础：区块、语句、预处理器、内置数据类型、数组、指针
Object-Oriented C++：class、封装、继承、多态、虚函数
Template C++：模板元编程（TMP）
STL：template程序库，对容器、迭代器、算法和函数对象的规约和配合

2 尽量使用const、enum、inline替换 #define

在编译之前预处理器会替换掉宏定义的内容，所以编译器不可见，当程序编译出现此变量的错误信息时，无从查找，所以尽可能的使用编译阶段能被编译器检查的。

#define PI 3.14
或者
const double PI = 3.14;  //尽量选择这种形式

总结：

对于单纯的常量，建议使用const或enums替换#define
对于形似函数的宏，最好使用inline函数替换#define

3 尽可能的使用const

3.1 const修饰指针

使用const可以增加一些限制，比如STL中的迭代器不能指向不同的东西，就可以设置指针是const的，如T *const;
如果希望迭代器指向的东西不可以被改变，就可以设置 const T *;

3.2 const修饰成员函数

调用：const的成员函数只能由const的对象调用，const的成员函数中不能调用非const的成员函数
访问成员变量：const的成员函数不能修改类的成员变量

3.3 logic constness和bitwise constness

一个const的修饰的成员函数，业务需求在不修改类的核心成员变量基础上，要修改非核心成员变量值，此时语法会报错，这是logic constness
给那个非核心成员变量添加mutable修饰，这样就可以通过编译，这个是bitwise constness。
总结：

将某些东西声明为const 可帮助编译器侦测出错误用法。const 可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。
编译器强制实施bitwise constness,但你编写程序时应该使用“概念上的常量性（conceptual constness）。
当const和non-const成员函数有着实质等价的实现时，令non-const版本调用 const 版本可避免代码重复。

4 对象在使用前先进行初始化

4.1 类成员初始化之构造函数内赋值 or 初始化列表赋值

必须使用初始化列表：const修饰的成员变量不能进行赋值操作，所以必须初始化列表赋值
内置类型差异不大，非内置类型，如string，在构造函数内赋值，首先会调用缺省的构造函数一次，然后再调用operator=函数赋值一次，调用了两次函数。
而采用初始化列表只会调用拷贝构造函数一次完成初始化。

4.2 不同文件定义的non-local static对象的初始化次序问题

static对象：存储在内存的data段和bss段中的对象，非堆栈中，作用域于整个程序的生命周期内。（static关键字声明的对象是static对象中的一种）
local static：在函数内部的static对象
non-local static：除此之外的则是non-local static对象，比如:global作用域内的static对象，namespace作用域内的static对象等。
修改办法：既然static对象只有一份拷贝，且只初始化一次，很容易想到“单例模式”。
使用local static对象，首次使用时初始化，返回其引用即可（local static声明周期是整个程序），以后再使用无需再次初始化。

class FileSystem{
public:
……
std::size_t numDisks()const;
……
};
FileSystem& tfs()
{
	static FileSystem fs;
	return fs;
}

总结：

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

构造、析构和赋值运算相关
每一个类中都有构造函数、析构函数、赋值操作符。这几个函数是一个类最根本的函数，它控制着创建对象并初始化、对象消亡时的清理以及摆脱旧值赋新值。这样函数如果有问题，那么影响极为严重。
拷贝构造函数和赋值函数的区别？
拷贝构造函数是一个对象初始化一块内存区域，这块内存就是新对象的内存区，而赋值函数是对于一个已经被初始化的对象来进行赋值操作。

5 C++默默编写调用了哪些函数

一个空类，经过编译器处理后会有默认构造函数、复制构造函数、赋值操作符和析构函数。这些函数都是public且inline。

6 拒绝编译器默认生成的函数

如果我们想阻止使用这两个函数，我们可以声明它们为private。
只声明，不实现。如果普通的调用会在编译阶段出现错误（无法访问private），但是友元和member函数却可以访问，这样的话错误会发生的链接阶段，因为我们只是声明，没有实现。
将错误提前到编译阶段是最好的，毕竟越早出现错误越好。可以通过继承来实现，在这设计一个不可以复制的类。

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

7 为多态基类声明virtual析构函数

7.1 virtual虚函数

通常存在于继承关系中，当使用一个基类指针或者引用来调用子类函数时，调用虚函数，实际调用的是子类的版本。
虚函数最关键的特点是“动态联编”，它可以在运行时判断指针指向的对象，并自动调用相应的函数。

7.2 基类的析构函数声明为虚函数

在多层次的继承关系的类中，调用子类一般通过基类的指针或引用。析构对象时需要delete，但是多态的特征决定了，如果不把函数声明为virtual，指针调用的析构函数是基类的，子类内存并不会释放，会造成内存泄漏。
同理，在基类中要实现多态的函数都应该是虚函数virtual。
当一个类不用做基类时，如果把其析构函数声明为虚函数是个馊主意。因为虚构函数是通过虚函数表调用的，在调用虚函数时多一步指针操作；除此之外，其对象占用的内存空间也会多一个虚函指针。
举个例子：
一个类不含虚函数，一般不适合做基类。例如string类不含任何的虚函数，就不能作为基类

class SpecialString:public std::string{
……
};

这种做法是错误的，STL中的容器都没有虚的析构函数。

总结：

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

8 别让异常逃离析构函数

容器的销毁会调用析构函数，但是此时析构函数如果抛出异常，容器内剩余的对象不被销毁就会造成内存泄漏。此时，如果继续销毁的话，就会继续抛出异常，会导致不明确行为。
解决办法：
（1）如果close抛出异常，就终止这个程序。通常通过调用abort完成。
（2）将 close() 的执行移交给用户，然后再在析构函数中try and catch，吞下这个异常。

// 修改后的DBConn类实现
class DBConn {
public:
    //......
    void close() {    // 要求用户自己关闭数据库对象
        db.close();
        closed = true;
    }
    //......
    ~DBConn() {
        if (!closed) {    // 如果用户忘记了这么做，就采用 try catch 机制吞下异常。
            try {
                db.close();
            }
            catch (...) {
                // 记录此次 close 失败
                //......
            }
        }
    }
    //......
private:
    //......
    DBConnection db;
    bool closed;    // 增设此变量用以判断用户是否已经自行调用 close()，用户也可根据此变量判断 close() 是否顺利执行并作出相应的异常处理。
    //......
};

总结：

析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。
如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么 class 应该提供一个普通函数（而非在析构函数中）执行该操作。

9 不在构造和析构函数中调用virtual虚函数

在继承关系的类中，基类型构造期间virtual函数绝对不会下降到派生类型阶层，这个时候子类的对象的构造还没有完成，此时的virtual是失效的。
同理在析构函数中，派生类的对象首先会被析构，此时调用的实际是基类的析构函数，而基类是纯虚函数，调用就会出错。
因为“那些成员变量处于未定义状态”，所以“在base class 构造和析构期间调用的virtual 函数不可下降至derived classes。"
总结：
在构造和析构期间不要调用virtual 函数，因为这类调用从不下降至 derived class（比起当前执行构造函数和析构函数的那层）

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

实现连锁赋值操作，重写operator=。
方法一：如果operator=不返回一个引用，返回一个临时对象，也可以实现连锁赋值。但这个临时对象的构建会调用拷贝构造函数。【一次赋值操作，一次拷贝构造】
方法二：返回一个引用，只调用一次赋值，不会再执行拷贝构造
总结：
令operator=返回一个reference to *this

11 在operator=中实现“自我赋值”（没看懂）

总结：

确保当对象自我赋值时 operator= 有良好行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及 copy-and-swap。
确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。

12 复制对象时勿忘其每一部分

复制对象操作包括：

拷贝构造函数
赋值操作符
背景：在赋值操作过程中，基类的拷贝构造函数不会被调用。
总结：
Copying 函数应该确保复制“对象内的所有成员变量”及“所有 base class 成分”
不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第个函数中，并由两个coping 函数共同调用。

3 资源管理篇
C++用到的系统资源，用完之后必须还回去

13 使用对象管理资源

C++不能提供垃圾回收的机制，因此回收资源的任务交给了开发者。
如何将释放资源操作封装进资源管理对象中？
我们可以用对象来包装资源，并在析构函数中释放它。这样客户便不需要维护资源的内存了。 std::auto_ptr便是这样一个对象，它被称为智能指针（smart pointer）。典型的使用场景是，资源在堆空间中存储但只在局部被使用。
【扩展】资源管理对象的实现框架正是RAII原则：acquisition is initialization，用一个资源来初始化一个智能指针。指针的析构函数中释放资源。
auto_ptr被销毁时，会自动删除它所指对象。
使用对象管理资源的两个关键原则：
（1）获得资源后立刻放进管理对象（managing object）内。以上代码中createInvestment返回的资源被当做其管理者 auto_ptr 的初值。实际上“以对象管理资源”的观念常被称为“资源取得时机便是初始化时机”(Resource Acquisition Is Initialization；RAII），因为我们几乎总是在获得一笔资源后于同一语句内以它初始化某个管理对象。有时候获得的资源被拿来赋值（而非初始化）某个管理对象，但不论哪一种做法，每一笔资源都在获得的同时立刻被放进管理对象中。
（2）管理对象（managing object）运用析构函数确保资源被释放。不论控制流如何离开区块，一旦对象被销毁（例如当对象离开作用域）其析构函数自然会被自动调用，于是资源被释放。如果资源释放动作可能导致抛出异常，事情变得有点棘手，但条款8已经能够解决这个问题，所以这里我们也就不多操心了。

总结：

为防止资源泄漏，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源。
两个常被使用的RAII classes分别是 trl::shared_ptr和auto_ptr。前者通常是较佳选择，因为其copy行为比较直观。若选择 auto_ptr,复制动作会使它（被复制物）指向 null。

14 在资源管理类中注意拷贝行为

如何禁止RAII对象的拷贝行为？
（1）禁止复制。许多情况下，复制RAII对象并不合理。这时候便可以禁止复制，只需将拷贝函数设为私有，条款6有讲述。
（2）对管理资源使用引用计数法。
（3）复制底层资源（“深度拷贝”）
（4）转移底部资源的拥有权（auto_ptr）

总结：
复制 RAII 对象必须一并复制它所管理的资源，所以资源的

copying 行为决定RAII 对象的 copying行为。
普遍而常见的 RAII class copying行为是：抑制copying、施行引用计数法（reference counting）。不过其他行为也都可能被实现。

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

get成员函数实现显式转换（安全，受欢迎）
隐式转换函数（方便）例：

class Tmp{
public:
    ...
    operator TmpConvertType() const  //隐式转换函数
    { return t; }
    ...
private:
    TmpConvertType t;
};

总结：

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

16 成对使用new和delete时采用相同形式

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

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

4 设计与声明
下面讲的是关于接口设计和声明的做法。设计接口一个很重要的准则是：让接口容易被正确使用，不容易被误用。这是一个大的准则，细化之后包括很多内容：正确性、高效性、封装性、维护性、延展性以及协议的一致性。

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

好的接口很容易被正确使用，不容易被误用；努力达成这些性质
“促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容；
“阻止误用”的办法包括建立新类型，限制类型上的操作，束缚对象值，以及消除用户的资源管理责任
tr1::shared_ptr支持定制型删除器，可预防DLL问题，可被用来自动解除互斥锁等等

19 设计class犹如设计type

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

值传递会发生对象切片的行为
对象切片：用子类对象对基类对象进行赋值运算时会将子类对象独有的(非继承的部分)函数和变量自动“切去”的机制。只留下子类继承来的基类原有的“切片”来对基类的对象进行赋值。简而言之，就是子类特有的功能被切割了，只留下基类中的行为，调用的是基类的。
拓展：多态失效的情形。
多态：多态是指：父类的引用或指针指向子类对象，从而使用一个基类下多个子类的重写方法
（1）静态联编
静态联编导致的父类引用或指针调用子类重写方法，实际调用结果为父类中方法，但是静态联编可用使用虚函数来解决，从而恢复多态。
静态绑定的方法调用在编译时就指定了其调用方法，此时就算是使用向上类型转换(子类的对象)，受到调用的依旧是基类方法
（2）对象切片slicing
对象切割与静态联编相似，对象切割也会导致调用的方法变为基类方法，但对象切割并不是静态联编导致的，也不能通过虚函数解决
当把一个派生类对象赋值给一个基类对象时（并不是使用父类指针或引用接收子类对象），会发生对象切割。(另外用基类对象强制转换派生类对象也会)，调用的是基类的行为。

值传递与引用传递：
（1）值传递会发生多次初始化和赋值的行为，开销较大。采用引用这种方式传递，没有新对象创建，所以自然没有构造和析构函数的调用。
（2）值传递的对象在多态行为中，子类会发生对象切割。需要采用引用传递
总结：

尽量以 pass-by-reference-to-const 替换 pass-by-value。前者通常比较高效，并可避免切割问题（slicing problem）
以上规则并不适用于内置类型，以及 STL 的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。

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

在使用引用传递时，一定要注意引用只是一个对象的别名，那个对象是必须已经存在的，然后才有别名。

函数返回一个对象的引用必须先创建这个对象
函数如果返回一个值对象的话，开销很多，多次的构造、拷贝和析构
返回对象的指针，使用者不进行delete会造成内存泄漏
定义返回对象为static，多线程可能会有问题
解决办法：一个必须返回新对象的函数的正确写法，就是让那个函数返回一个新对象。
总结：
绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated 对象，或返回pointer或reference指向一个local static 对象而有可能同时需要多个这样的对象。条款 4 已经为“在单线程环境中合埋返回 reference指向一个local static 对象”提供了一份设计实例。

22 将成员变量声明为private

总结：
1、将成员变量声明为private。这可以赋予客户访问数据的一致性、可细微划分访问控制、允许约束条件获得保证，并提供class作者以充分弹性实现。
2、protected并不比public更具有封装性。

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

这个条款讲解成员函数和友函数的区别。
成员变量应该是private，否则就有无限多函数可以访问它，毫无封装可言。能访问private成员变量的函数只有class的member函数、friend函数而已。在一个member函数和一个non-member、non-friend函数之间做抉择，如果两者提供相同的机能，显然后者提供了更大的封装。
总结：
用non-member、non-friend函数替换member函数，这样可以增加封装性、包裹弹性和机能扩充性。

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

总结：
如果需要为某个函数的所有参数（包括this指针所指向的隐喻参数）进行类型转换，这个函数必须是个non-member函数

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

总结
1、如果std::swap不高效时，提供一个swap成员函数，并且确定这个函数不抛出异常。
2、如果提供一个member-swap,也应该提供一个non-member swap来调用前者。对于class（非class template），要特化std::swap。
3、调用swap时，针对std::swap使用using形式，然后调用swap并且不带任何命名空间资格修饰。
4、为“用户定义类型”进行std template全特化时，不要试图在std内加入某些对std而言是全新的东西

实现部分

26 尽可能延后变量定义

定义了一个变量，然后程序在某处抛出了异常终止了，结果该变量没有用到，所以在最近要使用的时候进行抛异常。
总结：
尽可能延后变量定义式的出现。这样可以增加程序清晰性并改善效率。

27 尽量少做转型动作

C++中提供四种新式转型：

const_cast<T>(expression)
dynamic_cast<T>(expression)
reinterpret_cast<T>(expression)
static_cast<T>(expression)

总结
1、应该尽量少使用转型，尤其是在注重效率的代码中使用dynamic_cast。如果需要转型，试着设计无需转型代替。
2、如果必须使用转型，把它隐藏在函数内，客户通过接口使用，而不是由客户来实现转型。
3、使用新式的C++ style转型来代替旧的转型，因为新式的转型很容易辨识出来，而且它们有分类。

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

总结
避免返回handles（reference、指针、迭代器）指向对象内部。遵守这个条款可以增加封装性，帮助const成员函数的行为像个const，并将发生“虚吊号码牌”（dangling handles)的风险降到最低。

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

因此当我们编写或修改代码时，应该考虑如何让它具备异常安全性。
首先是“以对象管理资源”（条款13），组织那些可能泄露的资源。
然后挑选三个“异常安全保证”中的一个实施到我们所编写的每一个函数身上（以“现实可操作条件”为最强烈等级）。如果我们调用非异常安全代码，那么我们就别无选择了，只能将它设为“无任何保证”。将我们做的选择写成文档，为了给客户看，以及为了将来的维护代码。
函数的“异常安全性保证”是其可见接口的一部分，我们应该慎重选择。
总结

异常安全函数（Exception-safe functions）即使发生异常，也不会发生资源泄露或数据结构败坏。这样的函数分为三种：基本型、强烈型、不抛异常型。
“强烈保证”往往能够以copy-and-swap实现，但是“强烈保证”未必那么必要或有现实意义。
函数提供的“异常安全保证”通常最高只等于其所调用函数中，“异常安全性”最低的决定。

30 透彻了解inlining的里里外外

内联函数优势：

内联函数代码被放入符号表中，在使用时进行替换，和宏展开一样，效率很高；
编绎器在调用一个内联函数，首先会检查参数问题，保证调用正确，与对待普通的函数一样，消除了隐患及局限性；
内联函数劣势：
不允许过多的代码，代码过多的话会造成大的内存消耗，最好在5行以内；
不允许有循环或者开关语句，如果有的话，执行函数代码时间比调用开销大。

inline函数为什么放到头文件？
大多数建置环境（build environment）在编译过程中进行inlining，将一个“函数调用”替换为“被调用函数的本体”，在替换时需要知道这个函数长什么样子。Inlining在大多数C++中是编译期行为。
Templates通常也放置在头文件，因为它一旦被使用，编译器为了将它具体化，也需要知道它长什么样子。（有些编译环境可以在链接期间才执行template具体化，但是编译期间完成的更常见）。
总结
1.将大多数inlining限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级（binary upgradability）更容易，使代码膨胀问题最小化，使程序提升效率机会最大化。
2.function tempates出现在头文件，但是不一定必须是inline。

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

参考： https://segmentfault.com/a/1190000002790854
总结

支持“编译依存性最小化”的一般构想是：相依于声明式，不要相依于定义时。基于此构想的两个手段是Handle classes和Interface classes。
程序库头文件应该以“完全且仅有声明式”（full and declaration-only forms）的形式存在。不论是否这几templates，这种做法都是适用。

继承与面向对象设计

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

总结

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

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

总结

derived classes内的名称会遮掩base classes内的名称。在public继承下从来没有人希望如此。
为了让遮掩的名称在derived class内重见天日，可以使用using声明或转交函数(forwarding function）。

34 区分接口继承和实现继承

总结：
接口继承和实现继承不同。在public继承下，derived classes总是继承base classes的接口。
pure virtual函数只具体指定接口继承。
impure virtual函数具体指定接口继承和缺省实现继承。
non-virtual函数具体指定接口继承和强制性实现继承。

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

总结

virtual函数的替代方案包括NVI手法及Strategy设计模式的多种形式。NVI手法自身是一个特殊形式的Template Method设计模式。
将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员。
tr1::function对象行为就像一般函数指针。这样的对象有更大的弹性。

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

on-virtual函数是静态绑定的，子类无法实现函数重写的功能

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

总结：
不要重新定义一个继承而来的缺省参数值，因为缺省参数值是静态绑定，而virtual函数（你唯一应该覆写的东西）是动态绑定。

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

组合关系：组合（composition）是类型之间的一种关系，一个类型的对象包含其他类型对象便是这种关系：
应用域：程序中对象相当于你所塑造现实世界中某物，例如地址、电话号码，这样的对象属于应用域（application domain）。【组合】
实现域：还有一些是实现细节上的人工复制品，例如缓冲区（buffers）、互斥器（mutexes）、查找树（search tree）等，这些是实现域（implementation domain）。【is-implemented-in-terms-of】
总结：
复合（composition）的意义和public继承完全不同。
在应用域（application domain），复合意味has-a；在实现域（implementation domain），复合意味is-implemented-in-terms-of（根据某物实现出）。

39 明智而审慎的使用private继承

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

40 明智而审慎的使用多重继承

总结：
多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要。
virtual继承会在对象大小、速度、初始化、赋值造成成本增加。如果virtual base class不带任何数据，那么将是最具有使用价值情况。
多重继承的确有正当用途。其中一个情节设计public继承某个Interface class和private继承某个协助实现的class。

模板与泛型编程

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

总结：
class和template都支持接口和多态。
class的接口是显式的，以函数签名为中心，多态是通过virtual函数发生于运行期。
template的接口是隐式的，基于有效表达式。多态是通过template具体化和函数重载解析（function overloading resolution）发生在编译期。

42 了解typename的双重意义

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

43 学习处理模板化基类内的名称

总结：
可在derived class templates内通过this->指涉base class templates内的成员名称，或藉由一个明白写出base class资格修饰符完成。

44 将与参数无关的代码抽离templates

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