Effective C++ 精华总结

ゞ浴缸里的玫瑰 2022-07-13 14:10 214阅读 0赞

**– 此文由我在迅雷任职时的leader 冯雅杰 整理形成.**

*   *   *  让自己习惯C
            
             *  使用constenuminline替换宏
             *  尽量使用const
             *  确定对象被使用前已先被初始化
         *  构造析构赋值运算
            
             *  了解C默认编写并调用哪些函数
             *  若不想使用编译器生成的函数就应该明确拒绝
             *  为多态基类声明virtual析构函数
             *  不要在析构函数中抛出异常
             *  不要在构造或析构函数中调用虚函数
             *  令operator返回一个this的引用
             *  在operator中处理自我赋值
             *  复制时勿忘复制每一个成员
         *  资源管理
            
             *  以对象管理资源
             *  资源管理对象复制的机制
             *  在资源管理类中提供对原始资源的访问
             *  成对使用new和delete时要使用相同形式
             *  以独立语句将newed对象置入智能指针
         *  继承与面向对象设计
            
             *  考虑virtual函数以外的其他选择
         *  模板与泛型编程
            
             *  了解隐式接口和编译器多态
             *  了解typename的双重意义
             *  学习处理模板化基类的名称

### 让自己习惯C++ ###

#### 使用const，enum，inline替换宏 ####

*  用const，enum替换宏常量
    
    在编译时，如果宏常量所在部分出现编译错误，错误信息会提到替换后的常量，而不是宏符号，有时候会令人无法理解，以及找到出  
    错的位置，例如
    
        #define RATIO 1.6 // 如果使用RATIO的地方编译出错，则编译信息只会提到1.6，而非RATIO
    
    对于上面的例子，使用const double RATIO = 1.6;替换宏会更好。  
    如果你要限定常量的作用域在类中，且只有一份，你需要在类中声明static const常量，有些（如int类型）常量可以在声明时定  
    义，有些（如指针类型）不行，这时需要在类定义式中赋值：
    
        class MyClass
        {
        public:
          static const int AVERAGE = 60;
          static const char *STR1;
          static const string STR2;
        };
        const char *STR1 = "hello";
        const char *STR2 = "world";
 *  使用inline替换宏函数
    
    宏函数的某些弊端
    
        #define MAX(a,b) ((a) > (b) ? (a) : (b))
        
        ...
        int a = 5;
        int b = 0;
        MAX(a++, b); // 1
        MAX(a++, b + 10); // 2
    
    以上代码，在1中a被累加2次，在2中a被累加1次，这种函数容易被调用者误用，而使用inline函数拥有同样的效率，且没有这样的问题
    
        template<class T>
        inline T max(T a, T b)
        {
          return (a > b ? a : b);
        }

#### 尽量使用const ####

const可以使用在多种场合，例如常量，函数参数，const 成员函数等，以下为几个重要的使用场景

*  指针及迭代器
    
        const char *p1 = "const string";
        char const *p2 = "const string too";
        char * const p3 = "const pointer";
        const char * const p4 = "string and pointer are const";
    
    p1和p2一样所指的内容为常量，p3变量本身为常量，记住一点，const在*左边的表示指针所指的内容为常量，在*号右边表示指针为常量
    
        vector<int> arr;
        vector<int>::const_iterator cit = arr.begin();
        const vector<int>::iterator it = arr.begin();
        *cit = 1; // wrong
        it++; // wrong
    
    iterator可以看做是指针的一种实现，const iterator即为该指针为const，所以it++会出错，如果要表示迭代器所指的内容是常  
    量，需要用const\_iterator
 *  函数返回值
    
    函数返回const类型的对象，有时候可以避免某些错误，而这些错误可能会很难发现，例如Point是二维空间内的一个点对象
    
        class Point
        {
        public:
          int x;
          int y;
        };
        Point &operator+(const Point &lhs, const Point &rhs);
        // ...
        Point a,b,c;
        // ...
        if (a+b == c)
        // ...
    
    如果这时候你误把‘==’写成了‘=’，而你的‘operator+’的实现没有返回const，则会导致‘a+b=c’这种非常理的事情发生，  
    且‘if’条件表达式可能永远为真，正确的做法是让‘operator+’返回const引用
    
        const Point &operator+(const Point &lhs, const Point &rhs);
 *  const成员函数
    
    改善C++程序效率的一个根本办法是pass by reference-to-const，而这一技术的前提是，const成员函数可以用来处理  
    const对象。两个函数因为常量性（constness）不同，可以被重载
    
    有的const成员函数表面上不改变对象的成员，但实际上还是可以通过它对成员进行改变，例如：
    
        class TextBlock {
        public:
          ...
          char &operator[](std::size_t position) const
          { return pText[position];}
        private:
          char *pText;
        }
        ...
        const TextBlock tb;
        ...
        char first = tb[0];
        first = 'A';  // first为pText第一个元素的引用，这一行改变了pText指向的内容
    
    为了让const成员函数真正做到不改变对象的成员，当期返回内部成员引用时，请使用const的引用，例如上面的例子  
    const char &operator\[\](std::size\_t position) const;
    
    有些成员可能需要不受const成员函数的限制，例如一些缓冲数据
    
        int get_length() const
        {
          if (invalid_length) {
              length = strlen(pText); // length和invalid_length属于缓冲数据，它们可以让程序效率提升
              invalid_length = false;
          }
          return length;
        }
    
    这时候我们需要使用mutable来释放掉non-static成员的const约束
    
        class TextBlock {
        public:
          ...
          int get_length() const;
        private:
          char *ptext;
          mutable int length;
          mutable bool invalid_length;
        }
 *  const和non-const成员函数中避免重复
    
    上述说了两个函数因为常量性的不同，可以被重载，而重载的两个函数代码基本上是一致的，为了减少代码冗余，我们可  
    以另非const的函数来调用const的函数，例如
    
        class TextBlock {
        public:
          const char &operator[] (int position) const {
              .... // 函数步骤 1.边界检查，2.日志，3.检查数据完整性
              return ptext[position];
          }
        
          char &operator[] (int position) {
              return const_cast<char&>(static_cast<const TextBlock>(*this)[position]);
          }
        private:
          char *ptext;
        };
    
    以上有两层转换：
    
    1.  利用static\_cast将对象this转换为const this，则它调用的operator\[\]为const版本
    2.  利用const\_cast将返回的const char&转为char &
    
    为避免代码重复，只能通过调用const版本来实现，反之不行

#### 确定对象被使用前已先被初始化 ####

1.  对于内置类型，务必在使用前初始化，否则会出现不可预知的错误
2.  对于自定义类型，需要在构造函数时进行初始化
    
    理解构造函数的初始化和赋值：构造函数在初始化列表中进行初始化，而不是在函数体里面，构造函数体里面对成员变量  
    赋初值调用的是赋值操作，如果你这样做，会浪费初始化列表中对成员变量调用的默认构造函数操作，所以尽量在初始化  
    列表中对成员变量进行初始化，初始化顺序以成员变量的声明顺序为准。
    
    特例：如果成员变量是const或reference，必须要在初始化列表中初始化，不能被赋值，所以最好的做法是总是使用成  
    员初值列表。
3.  static对象的初始化

**概念：**  
static对象包括：  
1. 全局对象  
2. 定义于namespace作用域内的对象  
3. 在class内，在函数内，以及在file内被声明为static的对象

local static对象：函数内被声明为static的对象  
none local static对象：非local static的static对象

问题：

> 现在有两个源文件，每个源文件中包含一个none local static对象，且其中一个对象A的初始化动作依赖另一个对象B，而B  
> 有可能尚未初始化，因为C++对这样两个对象的初始化顺序是未定义的。

如何解决：

> 将none-local static对象转换为local static对象，例如：

class FileSystem {};
    ...
    FileSystem &tfs() {
        static FileSystem fs;
        return fs;
    }
    ...
    class Dir {
    public:
        Dir() {
            ...
            int disks = tfs().num_disks(); // 通过td()初始化全局的Dir对象时，先确保static FileSystem对象先被初始化
            ...
        }
    };
    ...
    Dir &td() {
        static Dir dir;
        return dir;
    }

### 构造/析构/赋值运算 ###

#### 了解C++默认编写并调用哪些函数 ####

基本：  
\- 如果你没有声明，C++会默认为你声明和定义copy构造函数，copy assignment操作符，析构函数.  
\- 如果你没有定义任何构造函数，C++还会给你定义一个默认的构造函数。所有这些函数都是public inline的  
\- 编译器产生的析构函数是none-virtual的，除非该类的父类的析构函数是virtual的，编译器将会该类产生一  
个virtual的析构函数  
\- 如果你自己定义了一个构造函数，编译器是不会再为你创建默认构造函数的。

什么情况下编译器不会为你产生copy assignment操作符  
\- 成员变量是引用或者const

1.  C++不允许让引用改指其他对象
2.  const成员变量本身无法被修改
    
     *  如果父类的copy assignment操作符是private，编译器拒绝为其定义copy assignment操作符，毕竟编译器要调用  
        父类的copy assignment完成赋值，而其对于private声明是无能为力

#### 若不想使用编译器生成的函数，就应该明确拒绝 ####

有些对象你是不希望它被复制的，这时你需要明确拒绝编译器为你生成的拷贝构造函数和赋值操作符，有两种方法帮你  
做到这点：

1.  声明拷贝构造函数和赋值操作符为private，并且不实现它
    
    如果非friend函数或非成员函数企图对该对象做复制操作，编译器会发生警告：没有权限；如果是friend函数或成  
    员函数企图进行复制，链接器会发出警告：复制构造函数或赋值操作符未定义
2.  有时候你想把报警都移到编译时，这时候可以采用第二种方法：声明一个Uncopyable的空类，把复制构造函数和  
    赋值操作符声明为private，拒绝复制的类继承Uncopyable类即可：
    
        class Uncopyable {
        private:
           Uncopyable(const Uncopyable &);
           Uncopyable &operator=(const Uncopyable &);
        };
        
        class MyClass : private Uncopyable {
        ...
        }；
    
    这里如果企图复制MyClass对象，编译器会发出警告：权限不够。如果你企图复制MyClass对象，编译器会产生复制  
    构造函数和赋值操作符，而这些代码会理所当然调用父类Uncopyable的复制构造函数和赋值操作符，因为前者没有  
    权限调用后者，所以会发出警告。

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

永远遵从这样的原则：  
1. 带多态性质的base classes应该声明一个virtual析构函数，如果class带有任何virtual函数，它都需要拥有  
一个virtual析构函数  
2. 如classes的设计不是作为base classes使用，或者不是为了多态性使用，不要为其声明virtual析构函数

#### 不要在析构函数中抛出异常 ####

如果在析构函数中抛出异常，会导致程序出现不明确的行为，如果析构函数中调用了某 个函数，而该函数可  
能抛出异常，则你有两种办法处理该情况：

1.  终止程序，宁可让程序提前结束，也不能让不明确的事情发生
    
        class DBConn {
        ...
           ~DBConn() {
               try {
                   connection_.close()
               }
               catch (...) {
                   assert(0);
               }
           }
        
        private:
           DBConnection connection_;
        };
2.  吞掉该异常，并打印错误日志：将上述的assert(0);语句换成日志

#### 不要在构造或析构函数中调用虚函数 ####

在构造函数期间，base构造期中的虚函数不会下降至derived classes阶层，理由很简单，因为base部分先于derived部分  
初始化，由于derived部分没有初始化，虚函数很可能用到derived部分的成员变量，为了避免使用未初始化的变量，C++  
不会在这里调用子类的实现。

同样道理，对于析构函数，在base析构函数中如果有虚函数，也不会下降至derived classes阶层，由于析构过程进入  
base阶段，derived中的成员变量呈现出未定义状态，所以C++认为base中的virtual函数属于base class对象。

#### 令operator=返回一个\*this的引用 ####

我们在写代码时，可以采取这样的赋值

int var1,var2,var3;
    var1 = var2 = var3 = 15; // 连锁赋值

赋值运算采用的是右结合律，即

var1=(var2=(var3=15));

为了实现连锁赋值，operator=必须返回一个指向\*this的引用，即操作符的左侧实参。

Widget &operator=(const Widget &rhs)
    {
        ...
        return *this;
    }

#### 在operator=中处理“自我赋值” ####

自我赋值往往发生在比较隐晦的地方，例如

obj[i] = obj[j]; // 循环中，当i和j相同时，obj[x]指向的是同一个对象
    *px = *py; // 当px和py指向同一个对象时，发生自我赋值

自我赋值的隐患：假设你有一个类，类中有一个动态分配的指针：

class Widget {
    public:
        Widget &operator=(const Widget &rhs);
    private:
        Pointer *p;    
    };
    
    Widget &Widget::operator=(const Widget &rhs) {
        delete p;
        p = new Pointer(*rhs.p);
        return *this;
    }

如果此时发生自我赋值，则在上述第二条语句时会发生操作一个已被释放的指针，会造成程序存在不明确的行为。  
遇到这种情况，传统做法是做一个“证同测试”

Widget &widget::operator=(const Widget &rhs) {
        if (this == &rhs)
            return *this;
        delete p;
        p = new Pointer(*rhs.p);
        return *this;
    }

但以上实现仍然不是异常安全的，假如内存不足造成new Pointer抛出异常，最终对象会获得一个被删除了的指针p，  
操作这个对象的指针也会导致不明确的行为。为了避免这样的情况发生，较好的如下：

Widget &widget::operator=(const Widget &rhs) {
        if (this == &rhs)
            return *this;
        Point *tmp = p;
        p = new Pointer(*rhs.p);
        delete tmp;
        return *this;
    }

这样即便发生了异常，p还是会保持之前的状态。

#### 复制时勿忘复制每一个成员 ####

如果你自己实现复制函数——复制构造函数和赋值操作符，并且如果你没有复制所有内容，编译器是不会告诉你程序  
有问题的。

也许你觉得自己不会犯这样的错误，但在特殊情况下需要注意  
1. 类中增加了新的成员时  
2. 继承其他类时

尤其是第二点，当你继承其他类，如果你自己实现复制函数，你可能没有复制父类部分，这时候在copy构造函数期间，  
父类部分会在调用默认的构造函数，而在赋值操作符期间，父类部分只会保持原样。所以为了让父类部分能够正常的  
被复制，在copy构造函数阶段，需要在初始化参数列中调用父类的复制构造函数；在复制操作符时也调用父类的复制  
操作符。

### 资源管理 ###

#### 以对象管理资源 ####

在向堆中申请内存时，我们必须手动销毁它，例如我们有个工厂函数

int some_function() {
        Widget *w = createWidget();
        // ...
        delete w;
        return 0;
    }

在函数的…部分，由于开发者疏忽，或者添加新功能时没有注意，函数可能提前return，或者抛出异常，结果导致  
资源发生了泄露，所以靠人为来保证资源的释放是不可靠的。

为了保证资源能够在不使用时释放，函数的生命周期/对象的生命期，我们可以使用资源管理对象，这些对象内部使  
用析构函数保证对象在不使用后自动释放，常用的资源管理对象如智能指针tr1::shared\_ptr，它可以很好的支持复  
制函数，在复制时其中引用计数会递增，销毁时计数会递减，当减到0时才释放资源。上述代码可改为：

int some_function() {
        tr1::shared_ptr<Widget> w(createWidget());
        // ...
        return 0;
    }

tr1::shared\_ptr在释放时使用的是delete，而不是delete \[\]，所以其不支持数组的资源管理，如果偏要使用数组的话，  
建议使用vector或string进行管理，你还可以看看Boost的boost::scoped\_array和boost::shared\_array

#### 资源管理对象复制的机制 ####

对于资源管理对象，大体有两种复制的机制：  
1. 禁止复制  
2. 复制时增加引用计数，释放时减少引用计数，计数为0时销毁对象

第一种情况一般发生在使用锁的场景中，为了保证锁能够正常释放，我们会使用资源管理对象，并在对象生命周期结束  
时通过析构函数进行解锁。

class Locker {
    public:
        Locker(pthread_mutex_t *mutex)
        : m_mutex(mutex)
        {
            pthread_mutex_lock(m_mutex);
        }
        ~Locker()
        {
            pthread_mutex_unlock(m_mutex);
        }
    private:
        pthread_mutex_t *m_mutex;
    }

试想，如果Locker对象发生复制会怎样，所以我们一般会禁止这种类的复制。具体操作可以参照第5条  
第二种情况的使用即我们常说的智能指针，可以使用tr1::shared\_ptr对资源进行管理，不过上述Locker也可以使  
用tr1::shared\_ptr进行管理，唯一不同的是tr1::shared\_ptr默认情况是对指针进行delete操作，而不是unlock  
操作。为了让对象销毁时调用unlock操作，我们需要将unlock函数指针作为tr1::shared\_ptr构造函数的第二个参  
数，不过这种场景较少使用

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

资源管理类一般会重载operator->和operator\*操作符，它们允许隐式转换至底部原始指针

class Widget
    {
    public:
        ...
        void draw();
    };
    ...
    tr1::shared_ptr<Widget> pw(new Widget);
    pw->draw();

tr1::shared\_ptr这种资源管理类还提供get()方法，可以返回原始的资源指针

#### 成对使用new和delete时要使用相同形式 ####

这个主题主要是讲数组形式的new要以数组形式的delete释放；非数组形式的new要以非数组形式的delete释放，  
如果不是这样，程序行为是未定义的。

string *strA = new string;
    string *strB = new string[10];

delete strA; // right
    delete strB; // wrong

delete [] strB; // right
    delete [] strA; // wrong

尤其要注意，我们在typedef时不要对数组进行定义，例如

typedef string Address[4]; // 每个人的地址有4行，每行是一个string
    string *myaddr = new Address; // 这时从字面上就无法直观判断该动态内存需要delete []进行释放

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

直接看例子：

int func();
    ...
    void do_with_widget(tr1::shared_ptr<Widget> pw, int param);
    ...
    do_with_widget(tr1::shared_ptr<Widget>(new Widget), func()); // 运行时

上述第三行代码，第一个参数是一个临时的tr1::shared\_ptr只能指针对象，以复制方式传入  
do\_with\_widget函数，将该函数的调用进行分解，可能有以下顺序

1.  执行new Widget
2.  执行func()
3.  执行shared\_ptr的构造函数

如果在第二步func抛出一个异常，则会发生资源泄漏情况，为了避免这种泄漏，直观的做法是将智能指针的初始化单独执行：

tr1::shared_ptr<Widget> pw(new Widget);
    do_with_widget(pw, func());

这样即便func()抛出异常，也不会有资源泄漏

### 继承与面向对象设计 ###

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

假设我们需要对游戏中的角色计算其生命值，而不同职业的角色拥有不同的生命值算法，这时我们首先想到的就是利  
用C++中的virtual函数进行多态的实现：

class GameCharacter {
    public:
        virtual int calcHealth();
    };

由于这一设计如此明显，你可能忽视了其他的设计方案，本章的目的是介绍其他的多态方案，更多的丰富我们的设计。

籍由tr1::function完成以上多态：

class GameCharacter {
    public:
        typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;
        explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
            : healthFunc(hcf)
        {}
    
        int healthValue() const
        {
            return healthFunc(*this);
        }
    private:
        HealthCalcFunc healthFunc;
    };
    
    class GameLevel {
    public:
        float health(const GameCharacter &) const;
    };
    class EvilBadGuy: public GameCharacter {
     ....
    };
    ...
    GameLevel currentlevel;
    EvilBadGuy ebg2(std::tr1::bind(&GameLevel::health, currentLevel, _1)); // 使用某个成员函数计算生命值

tr1::function类型产生的对象可以持有任何于此签名式兼容的可调用物，所谓兼容，即这个可调用物的参数可被隐  
式转换为const GameCharacter&，而起返回类型可被隐式转换为int。

这样的实现有以下好处

1.  同一角色类型的不同实体（对象）可以有不同的生命计算函数
2.  某已知人物的生命值可以在运行时变更

### 模板与泛型编程 ###

#### 了解隐式接口和编译器多态 ####

#### 了解typename的双重意义 ####

在模板中，template和template的含义是相同的，但在某些地方，typename有  
特殊的含义。看如下例子：

template<typename C>
    void print2nd(const C& container)
    {
        if (container.size() >= 2) {
            C::const_iterator iter(container.begin());
            ++iter;
            int value = *iter;
            std::cout << value;
        }
    }

以上例子编译不通过，在于C::const\_iterator是一个嵌套从属名称，因为其依赖于template的名称C，而C++规定如果  
template中遭遇一个从属名称，它便假设这个名称不是类型，除非你告诉它是，所以我们必须告诉C++  
说C::const\_iterator是一个类型，只要紧临它之前放置关键字typename即可：

template<typename C>
    void print2nd(const C& container)
    {
         if (container.size() >= 2) {
            typename C::const_iterator iter(container.begin());
            ....
    }

例外，typename不能出现在父类列表内的嵌套从属名称之前，以及也不能在构造函数的初始化列表中作为父类的修饰。

template<typename T>
    class Derived : public Base<T>::Nested { // 在父类列表中，不允许typename
    public:
        explicit Derived(int x)
        : Base<T>::Nested(x) // 初始化列表中，不允许typename
        {
             typename Base<T>::Nested temp; // 嵌套从属类型名称，作为一个base class修饰符需加上typename
        }
    };

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

本节非常精彩，除了讲解了模板的基类函数的调用，还教会了我们在什么情况下使用模板。

假设我们要处理协议的加解密，每个协议会有加密和解密函数，并有加解密模板进行统一调用：

class ProtocalA {
    public:
        ...
        string encrypt();
        int decrypt(const string &);
    };
    
    class ProtocalB {
    public:
        ...
        string encrypt();
        int decrypt(const string &);
    };
    
    template<typename Proto>    
    class Cryptal {
    public:
        int encode(string &buffer) {
            Proto p;
            buffer = p.encrypt();
            return 0;
        }
    
        int decode(const string &buffer) {
            Proto p;
            p.decode(buffer);
            return 0;
        }
    };

然而有时候我们需要在此基础之上打印日志，我们可以很容易的想到利用继承机制来实现：

template<typename Proto>
    class LoggingCryptal : public Cryptal<Proto>{
    public:
        int logging_encode(string &buffer) {
            // loging begin
            encode(buffer);
            // login end
            ...
            return 0;
        }
    };

这里的实现首先要注意不要和基类的encode名称一致，但其仍然无法通过编译，原因在于编译器要等  
Cryptal具现化之后才能判别其是否有encode定义，而Cryptal很可能有其全特化版本，并且该  
特化版本是没有encode函数的，所以编译器宁愿不在模板基类中查找继承而来的名称。如果我们想让  
C++不查找模板基类函数的名称失效，有以下两种通用的办法：

1.  使用this
2.  使用using

// 第一种方法
    ...
    int logging_encode(string &buffer) {
        ...
        this->encode(buffer);
        ...
    }
    //第二种方法
    using Cryptal<Protol>::encode; // 告诉编译器，请它假设encode位于base class内
    int logging_encode(string &buffer) {
        ...
        encode(buffer);
        ...
    }