• Effective C++ 笔记

    一、让自己习惯C++

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

    条款02、尽量以const,enum,inline,替换 # define

    用编译器替换预处理器

    什么是预处理

    在C++中，预处理是指在编译过程之前的一个阶段，通过预处理器（preprocessor）对源代码进行处理的过程。预处理器会根据预处理指令（以井号#开头）对源代码进行文本替换、宏展开等操作，生成一个经过预处理的源文件。

    以下是常用的预处理指令及其作用：

    1. #define：用于定义宏常量或宏函数。#define指令会将所有出现在源代码中的宏名称都替换为指定的文本。

    2. #include：用于包含头文件内容。#include指令会将指定的头文件内容插入到该指令所在位置。

    3. 等等

    a、普通常量

    宏 预处理指令定义常量，如：

    # define ASPECCT_RATIO 1.653

    尽量用以下来代替：

    const 常量

    const double AspectRaio = 1.653;

    另外 定义一个常量的 char*-based字符创，必须写const两次

    const char* const authorName = "Acott Meyers"

    其实string对象通常比char*-based合宜

    const std::string authorName("Scott Meyers")

    b、class专属常量

    解释：

    1.常量的作用域限制在class内，必须让他成为 class 的一个成员

    2.确保此常量至多只有一份实体，必须让它成为一个 static 成员：

    1. class Game{
    2. private:
    3.     static const int NumTurns= 5;
    4.     int scores[NumTurns];
    5. };

    常量变量默认是不允许在类中直接初始化的。但是静态成员变量可以在类内进行初始化，所以是 static const int

    也可以使用enum来实现

    1. class Game{
    2. private:
    3.     enum {NumTurns = 5};
    4.     int scores[NumTurns];
    5. };

    c、看起来像函数的宏

    1. //以 a 和 b 的较大值调用f
    2. #define CALL_WITH_MAX(a, b) f((a) > (b)) ? (a) : (b)

    使用template inline 函数在编译阶段处理函数调用点的，减少函数调用的开销，也能获得宏的的效率

    1. template<typename T>
    2. inline T callWithMax(const T& a, const T& b){
    3.     return (a,b) ? a: b;
    4. }

    条款03、尽可能使用const

    const与指针

    如果关键字 const 出现在星号左边，表示被指物是常量，作函数参数时，不能在函数中改变

    1. #include 
    2.  
    3.  
    4. void add(const int* a, const int* b){
    5.     *a+=1; // 错误！
    6.     int c = *a + *b;
    7.     std::cout << c << '\n';
    8.  
    9. }
    10.  
    11. int main(){
    12.  
    13.     int num =1;
    14.     
    15.     
    16.     const int* a = #
    17.     const int* b = #
    18.  
    19.     add(a, b);
    20. }

    如果关键字 const 出现在星号右边，表示指针自身是常量

    1. #include 
    2. int main(){
    3.  
    4.     // 被指物为常量
    5.     char* const  p  = "hello";
    6.  
    7. //    p = "jason"; // 此时指针p不可以被修改，
    8.  
    9.     std::cout << *p << std::endl;
    10. }

    如果关键字 const 出现在星号两边，表示被指物和指针两者都是常量

    1. #include 
    2. int main(){
    3.  
    4.     char words[] = "hello";
    5.    
    6.      const char* const  p  = words;
    7.  
    8.     std::cout << *p << std::endl;
    9. }

    const与迭代器

    1. #include 
    2. #include 
    3. int main(){
    4.     std::vector<int> vec{1,2,3,4,5};
    5.  
    6.     std::vector<int>::const_iterator iter =
    7.         vec.begin(); // const 出现在迭代器右边
    8.     *iter += 10; // 不能通过迭代器修改被指内容
    9. //    ++iter;
    10.  
    11. }

    const与函数

    const成员函数

    1. #include 
    2.  
    3. class TextBlock{
    4. private:
    5.     std::string text;
    6. public:
    7.     TextBlock(const std::string & str):text(str){}
    8.     
    9.     const char& operator[] (std::size_t position) const{
    10.         return text[position];
    11.     }
    12.  
    13.     char& operator [] (std::size_t position){
    14.         return text[position];
    15.     }
    16. };
    17.  
    18.  
    19. int main(){
    20.     TextBlock tb("Hello");
    21.     std::cout << tb[0];  // 调用 non-const TextBlock::operator[]
    22.  
    23.     const TextBlock ctb("world"); // 调用 const TextBlock::operator[]
    24.     std::cout << ctb[0];
    25. }

    这里例子是太过造作。

    真实程序中 const 对象大多用于 passes by pointer-to-const 或 passes by reference-to-const

    应用在函数参数中

    1. void print(const TextBlock& ctb){
    2.     std::cout << ctb[0];
    3. }

    应用在成员函数

    1. include 
    2.  
    3. class Myclass{
    4. private:
    5.  
    6.     bool lengthIsValid;
    7.     mutable int num;
    8. public:
    9.     void test() const{
    10.         lengthIsValid = 0; // 错误！在const成员函数内不能赋值给lengthIsValid
    11.         num=10; // 正确，mutable关键字修饰的变量可以被修改
    12.     }
    13. };
    14.  
    15.  
    16. int main(){
    17.     Myclass myclass;
    18. }

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

    为避免在对象初始化之前过早地使用它们，需要做三件事：

    1. 为内置型对象进行手工初始化，因为C++不保证初始化
    2. 构造函数最好使用成员初值列，而不要在构造函数体内使用赋值操作。初值列列出的成员变量，其排列次序应该和他们在class中的声明次序相同。另外，C++17支持在类中直接对私有变量进行初始化而不通过构造函数
    3. 为免除“跨编译单元之初始化次序问题”，用 local static 对象替换 non-local static 对象

    前两点很好理解，这里对第三点给出例子解释：

    1. class FileSystem{
    2. public:
    3.     std::size_t numDisks(){}
    4. };
    5.  
    6. FileSystem& tfs(){
    7.     static FileSystem fs;
    8.     return fs;
    9. }
    10.  
    11. class Directory{};
    12. Directory::Directory(){
    13.     std::size_t disks = tfs.numDisks();
    14. }
    15.  
    16. Directory& tempDir(){
    17.     static Directory td;
    18.     return td;
    19. }

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

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

    如果你声明的一个空类，如：

    class Empty{};

    那么编译器会为它声明一个copy构造函数、一个copy assignment操作符和一个析构函数。如果你没有声明任何构造函数，编译器会你声明一个default构造函数。所有这些函数都是public且inline的。所以上面你声明的空类会被编译器处理为：

    1. class Empty{
    2. public:
    3.     Empty(){}       // default构造函数
    4.     Empty(const Empty& rhs){} // copy构造函数
    5.     ~Empty(){} // 析构函数
    6.     
    7.     Empty& operator=(const Empty& rhs){} // copy assignment操作符
    8. };

    调用copy构造函数的例子

    1. #include 
    2.  
    3. template<typename T>
    4. class NameObject{
    5. public:
    6.     NameObject(const char* name, const T& value);
    7.     NameObject(const std::string& name, const T& value);
    8.  
    9. private:
    10.     std::string nameValue;
    11.     T objecctValue;
    12. };
    13.  
    14. int main(){
    15.     NameObject<int> no1("Smallest Primer Number", 2);
    16.     NameObject<int> no2(no1); // 调用copy构造函数
    17.  
    18. }

    一个错误的例子：

    C++不允许“让 reference 改值向不同对象”

    更改const成员是不合法的

    基于以上两点，如下例子不正确：

    1. #include 
    2.  
    3. template<typename T>
    4. class NameObject{
    5. public:
    6.  
    7.     NameObject(const std::string& name, const T& value);
    8.  
    9. private:
    10.     std::string& nameValue; // C++不允许“让 reference 改值向不同对象”
    11.     const T objecctValue; //更改const成员是不合法的
    12. };
    13.  
    14. int main(){
    15.     std::string newDog("Persephone");
    16.     std::string oldDog("Satch");
    17.     NameObject<int> p(newDog, 2);
    18.  
    19.     NameObject<int> s(oldDog, 36);
    20.  
    21.     p = s;// 错误；C++不允许 让reference
    22.  
    23. }

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

    如果不希望 copy 构造函数 以及 copy assignment 操作符起作用，则应该声明为 private 并没有定义

    1. #include 
    2.  
    3. class HomeForSale{
    4. public:
    5.  
    6. private:
    7.     HomeForSale(const HomeForSale&);
    8.     HomeForSale& operator =(const HomeForSale&);
    9. };
    10.  
    11. int main(){
    12.     HomeForSale home;
    13.     home h1;
    14.     home h2(h1);
    15. }

    如此一来，就可以阻止        编译器暗自创建他们。而拷贝HomeForSale对象的时候，编译器会阻止:

    将连接期报错移动到编译期

    1. class Uncopyable{
    2. protected:
    3.     Uncopyable(){}                   // 允许对象构造和析构
    4.     ~Uncopyable(){}
    5. private:
    6.     Uncopyable(const Uncopyable&); // 但阻止copying
    7.     Uncopyable& operator =(const Uncopyable&);
    8. };
    9.  
    10. // class HomeForSale 不再声明 copy 构造函数 或 copy assign. 操作符
    11. class HomeForSale : private Uncopyable{};
    12.  
    13. int main(){
    14.     HomeForSale home1;
    15.     HomeForSale home2(home1);
    16.  
    17. }

    总结：

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

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

    C++11不存在 “ non-virtual 析构函数问题”，此条款略过

    条款08、别让异常逃出析构函数

    不要让异常逃离析构函数是指在析构函数中抛出异常时，不要让该异常传播到析构函数的调用点以外。这是因为对象的析构过程通常是在对象生命周期的最后阶段发生的，此时其他对象和资源已经被清理或释放。如果析构函数抛出异常并且该异常逃离了析构函数，将会导致以下问题：

    1. 对象的析构不完全：如果析构函数抛出异常，对象的析构可能无法完成，导致对象状态没有得到完全清理或释放。这可能会导致资源泄漏或其他未定义行为。

    2. 内存泄漏：如果在抛出异常之前执行了动态内存分配，并且在抛出异常后没有适当地释放该内存块，将会导致内存泄漏。

    3. 无法回滚操作：如果在对象构造期间进行了一些操作，并且在析构函数中发生异常，无法回滚这些操作。这可能会导致数据不一致或逻辑错误。

    为了避免异常从析构函数中逃离，可以采取以下措施：

    1. 在析构函数中捕获异常并处理：可以在析构函数中使用 try-catch 块来捕获异常，并在适当的情况下进行处理。例如，记录异常信息或执行必要的清理操作。

            析构函数抛出异常就结束程序。通常通过调用 abort 完成：

    1. #include 
    2.  
    3. class DBConnection{
    4. public:
    5.     static DBConnection create(){
    6.         static DBConnection db;
    7.         return db;
    8.     }
    9.  
    10.     void close(){
    11.         int num=0;
    12.         throw num; // 假装抛出异常
    13.     }
    14. };
    15.  
    16. //该类用于管理 DBConnection 资源,在其析构函数调用 DBConnection 的close，用以关闭数据库
    17. class DBConn
    18. {
    19. private:
    20.     DBConnection db;
    21. public:
    22.     ~DBConn() {
    23.         try{db.close();}
    24.         // 省略代码：制作运转记录，记下对close的调用失败
    25.         catch (int)
    26.         {
    27.             // 这里最好打印信息，因为QT IDE只会给你报崩溃的信息
    28.             std::abort();
    29.         }
    30.     }
    31.  
    32.     DBConn(DBConnection d):db(d){}
    33. };
    34.  
    35. int main()
    36. {
    37.     // 现在就可以这样写代码。
    38.     // dbc 对象销毁时候，会调用其析构函数，....自动关闭 DBConnection 的数据库
    39.     DBConn dbc(DBConnection::create());
    40. }

    本例的假设情况：

    如果程序遭遇一个“于析构函数期间发生的错误”后无法继续执行，“强迫结束程序”是个合理选项。毕竟它可以阻止异常从析构函数传播出去（那会导致不明确的行为）。也就是说调用 abort 可以抢险置“不明确行为”于死地。

    吞下因调用而发生的异常：

    修改上例代码中的DBConn类的析构函数如下：

    1.     ~DBConn() {
    2.         try{db.close();}
    3.         // 省略代码：制作运转记录，记下对close的调用失败
    4.         catch (int){}
    5.     }

    这里析构函数将异常吞掉了，一般而言，这是和坏主意，因为压制了“某些动作失败”的重要信息！然而有时候吞下异常也比负担“草率结束程序”或“不明确行为带来的风险”好。为了让这成为一个可行方案，程序必须能够继续可靠地执行，及时在遭遇并忽略一个错误之后。

    上面两种方法没有无法对“导致 close 抛出异常”的情况做出反应，另外一个思路是重新设计 DBonn接口，使其客户有机会对可能和出现的问题作出反应。例如 DBConn 自己可以提供一个close函数，给客户一个机会得以处理“因该操作而发生的异常”：

    1. #include 
    2.  
    3. class DBConnection{
    4. public:
    5.     static DBConnection create(){
    6.         static DBConnection db;
    7.         return db;
    8.     }
    9.  
    10.     void close(){
    11.         int num=0;
    12.         throw num; // 假装抛出异常
    13.     }
    14. };
    15.  
    16. //该类用于管理 DBConnection 资源,在其析构函数调用 DBConnection 的close，用以关闭数据库
    17. class DBConn
    18. {
    19. private:
    20.     DBConnection db;
    21.     bool closed=false;
    22. public:
    23.  
    24.     void close(){      // 供客户使用的新函数
    25.         db.close();
    26.         closed = true;
    27.     }
    28.  
    29.     ~DBConn() {
    30.  
    31.         if(!closed){              // 关闭连接（如果客户不那么做的话）
    32.             
    33.             try{db.close();}
    34.             catch(int) {
    35.                 // 如果关闭动作失败，
    36.                 // 记录下来并结束程序或吞掉异常
    37.             };
    38.         }
    39.     }
    40.  
    41.     DBConn(DBConnection d):db(d){}
    42. };
    43.  
    44. int main()
    45. {
    46.     // 现在就可以这样写代码。
    47.     // dbc 对象销毁时候，会调用其析构函数，....自动关闭 DBConnection 的数据库
    48.     DBConn dbc(DBConnection::create());
    49.     
    50.     
    51. }

    总结：

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

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

    如标题

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

    1.  
    2. #include 
    3.  
    4. class Widget{
    5. public:
    6.     Widget& operator =(const Widget& rhs){
    7.  
    8.         // 将右侧对象的值赋给左侧对象的成员变量
    9.         if (this != &rhs){
    10.             value = rhs.value;
    11.         }
    12.  
    13.         // 返回左侧对象
    14.         return* this;
    15.     }
    16.  
    17.     Widget(int num):value(num){}
    18.     Widget(){};
    19.  
    20.     void getValue(){
    21.         std::cout <<  "value: " << value << std::endl;
    22.     }
    23.  
    24. private:
    25.     int value;
    26. };
    27.  
    28. int main(int argc, char *argv[])
    29. {
    30.     Widget m1(10);
    31.  
    32.     Widget m2;
    33.     Widget m3;
    34.     
    35.     // 连锁赋值
    36.     m3=m2=m1;
    37.  
    38.     m3.getValue();
    39.     m2.getValue();
    40.     m1.getValue();
    41.  
    42.     return 0;
    43. }
    44.  
    45.

    本例子以operator=操作符为例， +=， -=， *=也适用

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

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

    三、资源管理

    条款13、以对象管理资源

    中心：资源取得时机便是初始化时机

    一般情况下：

    1. #include 
    2.  
    3. class Investment{};
    4.  
    5. Investment * creatInvestment(){
    6.     Investment* i = new Investment;
    7.     return i;
    8. }
    9.  
    10. void f()
    11. {
    12.     Investment* pInv = creatInvestment();
    13.  
    14.     // 中间代码省略
    15.  
    16.     delete pInv; // 必须释放pInv所指向对象，否则导致内存泄露
    17. }
    18.  
    19. int main(){
    20.     f();
    21. }

    但是有时候由于中间代码出现问题，delete pInv 语句会无法得到执行，这样便导致内存泄露！

    下面这个例子示范“以对象管理资源”的两个关键想法：

    获得资源后立即放进管理对象内

             creatInvestment() 返回的资源被当作其管理 unique_ptr的初值

    管理对象运行析构函数确保资源被释放

    1. #include 
    2. #include 
    3.  
    4. class Investment{};
    5.  
    6. Investment * creatInvestment(){
    7.     Investment* i = new Investment;
    8.     return i;
    9. }
    10.  
    11. void f()
    12. {
    13.     // 获得资源后立即放进管理对象内
    14.     std::unique_ptr pInv(creatInvestment());
    15.  
    16.     // 中间代码省略
    17.  
    18. //    delete pInv; // 管理对象运行析构函数确保资源被释放，不需要手动释放内存
    19. }
    20.  
    21. int main(){
    22.     f();
    23. }

    不过，unique_ptr 是 C++11 引入的智能指针模板，用于管理动态分配的内存资源。它提供了一个独占所有权的智能指针，确保只有一个指针可以访问动态分配的内存块，从而避免内存泄漏和悬挂指针（dangling pointer）的风险。这样做就不行：

    1. #include 
    2. #include 
    3.  
    4. class Investment{};
    5.  
    6. Investment * creatInvestment(){
    7.     Investment* i = new Investment;
    8.     return i;
    9. }
    10.  
    11. void f()
    12. {
    13.     // 获得资源后立即放进管理对象内
    14.     Investment* ptr = creatInvestment();
    15.     
    16.     //不能把同一块内存由两个unique_ptr管理者同时管理
    17.     std::unique_ptr pInv1(ptr);
    18.     std::unique_ptr pInv2(pInv1); // 不允许
    19.  
    20.     // 中间代码省略
    21.  
    22. //    delete pInv; // 管理对象运行析构函数确保资源被释放，不需要手动释放内存
    23. }
    24.  
    25. int main(){
    26.     f();
    27. }

    而STL容器要求其元素发挥 “正常的” 复制行为，因此容不得unique_ptr。

    但是shared_ptr就不一样了：

    1. #include 
    2. #include 
    3.  
    4. class Investment{};
    5.  
    6. Investment * creatInvestment(){
    7.     Investment* i = new Investment;
    8.     return i;
    9. }
    10.  
    11. void f()
    12. {
    13.     // 获得资源后立即放进管理对象内
    14.     Investment* ptr = creatInvestment();
    15.  
    16.     //同一块内存可以由两个shared_ptr管理者同时管理
    17.     std::shared_ptr pInv1(ptr);
    18.     std::shared_ptr pInv2(pInv1);
    19.  
    20.     pInv2 = pInv1; // 同上，无任何变化
    21.  
    22.     // 中间代码省略
    23.  
    24. //    delete pInv; // 管理对象运行析构函数确保资源被释放，不需要手动释放内存
    25. }
    26.  
    27. int main(){
    28.     f();
    29. }

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

    对于 heap-based 资源，可以用unique_ptr以及shared_ptr进行管理。但是别的资源就需要建立自己的资源管理类。

    下述例子实现了对 mutex* 的管理，并禁止复制，相当于unique_str:

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. void lock(mutex* pm){};
    6. void unlock(mutex* pm){};
    7.  
    8. class Lock{
    9. private:
    10.     mutex* mutexPtr;
    11.  
    12. public:
    13.     explicit Lock(mutex* pm):mutexPtr(pm)
    14.         {
    15.         lock(mutexPtr); // 构造函数获取资源
    16.         }
    17.  
    18.     ~Lock()
    19.     {
    20.         unlock(mutexPtr); // 析构函数释放资源
    21.     }
    22.  
    23. private:
    24.     // 不希望 copy 构造函数 以及 copy assignment 操作符起作用
    25.     Lock(const Lock&);
    26.     Lock& operator =(const Lock&);
    27. };
    28.  
    29.  
    30.  
    31. int main(){
    32.     mutex m;
    33.     Lock m1(&m);
    34.     Lock m2(m1); // 禁止复制，条款6
    35. }

    使用shared_ptr

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. void lock(mutex* pm){};
    8. void unlock(mutex* pm){};
    9.  
    10. class Lock{
    11. private:
    12.     std::shared_ptr mutexPtr;
    13.  
    14. public:
    15.     // 以某个 mutex 初始化 shared_ptr，
    16.     // 第二参数是unlock
    17.     // 当shared_ptr 被销毁时会调用unlock
    18.     explicit Lock(mutex* pm):mutexPtr(pm, unlock)
    19.         {
    20.         lock(mutexPtr.get()); // 构造函数获取资源
    21.         }
    22.  
    23.     // 不再声明析构函数
    24.     // 条款5-》class析构函数会自动调用其non-static成员变量的析构函数
    25.  
    26. };
    27.  
    28.  
    29.  
    30. int main(){
    31.     mutex m;
    32.     Lock m1(&m);
    33.     Lock m2(m1);
    34. }

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

    来看一个例子，就理解标题的意思：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class Investment{};
    7.  
    8. Investment * creatInvestment(){
    9.     Investment* i = new Investment;
    10.     return i;
    11. }
    12.  
    13.  
    14. int daysHeld(const Investment* pi){
    15.     return 10;
    16. }
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20.     std::shared_ptr pInv(creatInvestment());
    21.  
    22.     // 错误，函数需要的是Investment*指针！
    23.     // 传过来的却是类型为 std::shared_ptr对象
    24.     int days = daysHeld(pInv);
    25.  
    26.     return 0;
    27. }

    那么如何获得原始指针：

    方法一：使用shared_ptr的get成员函数，用来执行显式转换，也就是他会返回智能指针内部的原始指针（的复件）：

    1. int main(int argc, char *argv[])
    2. {
    3.     std::shared_ptr pInv(creatInvestment());
    4.  
    5.     //使用shared_ptr的get成员函数，获取智能指针内部的原始指针
    6.     int days = daysHeld(pInv.get());
    7.  
    8.     return 0;
    9. }

    方法二：就像（几乎）所有智能指针一样，shared_ptr也重载了指针取值（pointer deference）操作符（operator->和operator*），他们允许隐式转换至底部原始指针：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. class Investment{
    7.     //
    8. public:
    9.     bool isTaxFree() const{
    10.         return true;
    11.     }
    12. };
    13.  
    14. Investment * creatInvestment(){
    15.     Investment* i = new Investment;
    16.     return i;
    17. }
    18.  
    19.  
    20.  
    21. int main(int argc, char *argv[])
    22. {
    23.     // shared_ptr管理一笔资源
    24.     std::shared_ptr pi1(creatInvestment());
    25.  
    26.     // 经由 operator->f访问资源
    27.     bool taxable1 = !(pi1->isTaxFree());
    28.  
    29.  
    30.     // unique_ptr 管理一批资源
    31.     std::unique_ptr pi2(creatInvestment());
    32.  
    33.     // 经由 operator*访问资源
    34.     bool taxable2 = !((*pi2).isTaxFree());
    35.  
    36.     return 0;
    37. }

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

    必须一一对应：

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     std::string* stringPtr1 = new std::string;
    9.     std::string* stringPtr2 = new std::string[100];
    10.  
    11.     delete stringPtr1; // 删除一个对象
    12.     delete [ ] stringPtr2; // 删除一个由对象组成的数组
    13.  
    14.     return 0;
    15. }

    如果你喜欢用typedef:

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     typedef std::string AddressLines[4]; // 每个人地址有4行
    9.                                          // 每行是一个string
    10.  
    11.     // 注意，“new AddressLines” 返回一个string*,就像
    12.     // “new string[4]”一样
    13.     std::string* pa1 = new AddressLines;
    14.  
    15.     // 那必须匹配“数组形式”的delete
    16. //    delete pa1;//行为未有定义
    17.     delete [] pa1;
    18.  
    19.     return 0;
    20. }

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

    从int prioryty(){}阅读下述例子，即可理解标题：

    1. #include 
    2. #include 
    3.  
    4. class Widget{
    5. public:
    6.     Widget& operator =(const Widget& rhs){
    7.  
    8.         // 将右侧对象的值赋给左侧对象的成员变量
    9.         if (this != &rhs){
    10.             value = rhs.value;
    11.         }
    12.  
    13.         // 返回左侧对象
    14.         return* this;
    15.     }
    16.  
    17.     Widget(int num):value(num){}
    18.     Widget(){};
    19.  
    20.     void getValue(){
    21.         std::cout <<  "value: " << value << std::endl;
    22.     }
    23.  
    24. private:
    25.     int value;
    26. };
    27.  
    28. int priority(){
    29.     return 10;
    30. }
    31.  
    32. void processWidget(std::shared_ptr pw, int priority){}
    33.  
    34. int main(int argc, char *argv[])
    35. {
    36.     // shared_ptr构造函数需要一个原始指针（raw pointer）
    37.     // 但该构造函数是个explicit构造函数，无法进行隐式转换，
    38.     // 将自“new Widget”的原始指针转换为processWidget所要求的
    39.     // shared_ptr，所以下面这样写不能通过编译
    40. //    processWidget(new Widget, priority());
    41.  
    42.     // 这样写才能通过编译,干了三件事：如果是这个顺序
    43.     // 执行 “new Widget”、调用priority、调用new Widget构造函数
    44.     // 调用priority失败会“new Widget”返回的指针遗失，引发资源泄露
    45.     processWidget(std::shared_ptr (new Widget), priority());
    46.  
    47.     // 所以最好是使用分离语句
    48.     std::shared_ptr pw(new Widget); // 在单独语句内以智能指针
    49.                                             //存储new Widget所得对象
    50.     processWidget(pw,priority()); // 这个调用动作绝不至于造成泄露
    51.  
    52.     return 0;
    53. }

    分离语句即可说明：

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

    四、设计与声明

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

    很可能传一个错误的参数：

    1. #include 
    2.  
    3. class Date{
    4. public:
    5.     Date(int month, int day, int year){};
    6. };
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10.     Date d(30, 3, 1995); // 月份不可能大于12！！
    11.     return 0;
    12. }

    • std::shared_ptr 在构造函数中提供了一个可选的删除器（deleter）参数，用于自定义资源的释放方式。删除器是一个函数或者可调用对象，用于在shared_ptr的引用计数器变为0时释放资源。

      删除器可以是普通函数、函数指针、lambda 表达式等，只要符合指定的删除器的函数签名即可。删除器接受一个指向资源的指针（被shared_ptr管理的指针）作为参数，不返回任何值。

      下面是一个示例，展示了如何给 shared_ptr 提供自定义的删除器：

      1. #include 
      2. #include 
      3.  
      4. struct MyStruct {
      5.     void operator()(int* p) {
      6.         std::cout << "Deleting pointer using custom deleter...\n";
      7.         delete p;
      8.     }
      9. };
      10.  
      11. int main() {
      12.     std::shared_ptr<int> ptr(new int(42), MyStruct());
      13.  
      14.     // 使用默认删除器释放资源
      15.     std::shared_ptr<int> ptr2(new int(100));
      16.  
      17.     return 0;
      18. }

      在上面的示例中，MyStruct 是一个删除器类，它重载了operator()，在函数体中使用 delete 运算符释放资源。在创建 std::shared_ptr 时，通过提供 MyStruct 的实例作为构造函数的第二个参数，我们指定了自定义删除器。

      需要注意的是，使用删除器时，它必须与被管理指针的类型兼容，否则会导致未定义的行为。此外，当存在多个 shared_ptr 共享同一个对象时，它们必须使用相同类型的删除器。

      自定义删除器为我们提供了更大的灵活性，能够管理不同类型的资源释放方式，例如，在资源释放时执行一些额外的操作。

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

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

    首先来看下 pass-by-reference-to-const 的传递成本：

    1. #include 
    2.  
    3. class Person{
    4. public:
    5.     Person(){}
    6.     virtual ~Person(){}
    7.  
    8. private:
    9.     std::string name;
    10.     std::string address;
    11.  
    12. };
    13.  
    14. class Student: public Person{
    15. private:
    16.     std::string schoolName;
    17.     std::string schoolAddress;
    18.  
    19. public:
    20.     Student(){}
    21.     ~Student(){}
    22. };
    23.  
    24. bool validateStudent(Student s){
    25.     // 省略对Student对象的检查
    26.  
    27.     return 1;
    28. }
    29.  
    30. int main(int argc, char *argv[])
    31. {
    32.     Student plato;
    33.     bool platoIsOK = validateStudent(plato);
    34.     return 0;
    35. }

    这里例子中，无疑地Student的 copy 函数会被调用，以 plato 为蓝本将 s 初始化。同样明显地，当 validayeStudent 返回后， s 会被销毁。因此，对此函数而言，参数的传递成本是 “一次 Student copy 构造函数调用，加上一次 Student 析构函数调用”。

    而使用 pass by reference-to-const 可以回避上述那些构造和析构动作：

    bool validateStudent(const Student& s)

    const的作用：validateStudent 不能修改传入的Student

    除了效率之外，两种传递方式还有别的区别，来看看这里例子：

    1. #include 
    2.  
    3. class Window{
    4. public:
    5.     std::string name() const{
    6.         return "window\n";
    7.     }
    8.     virtual void display() const{
    9.         std::cout << "display from Window!\n";
    10.     }
    11. };
    12.  
    13. class WindowWithScrollBars: public Window{
    14. public:
    15.     // 重写了基类中的display方法
    16.     virtual void display() const{
    17.         std::cout << "display from WindowWithScrollBars!\n";
    18.     }
    19. };
    20.  
    21. void printNameAndDisplay(Window w){
    22.     std::cout << w.name();
    23.     w.display();
    24. }
    25.  
    26.  
    27. int main(int argc, char *argv[])
    28. {
    29.     WindowWithScrollBars wwsb;
    30.     printNameAndDisplay(wwsb);
    31.     return 0;
    32. }

    printNameAndDisplay函数的本意是，调用传入对象的display成员函数。也就是说，如果传入的是Window对象，就调用其display成员函数；如果传入的是WindowWithScrollBars对象，就其display成员函数。

    但是参数传递方式选择为 pass-by-value时候，即使传入的是WindowWithScrollBars对象，也是调用基类Window的display成员函数。下图是上例子的执行结果

    而将printNameAndDisplay函数参数传递方式修改为pass-by-reference-to-const时，就能实现该函数设计的本意：

    1. void printNameAndDisplay(const Window& w){
    2.     std::cout << w.name();
    3.     w.display();
    4. }

    但是对于内置类型，以及 STL 的迭代器和函数对象而言，比如 int，尽量选择 pass-by-value

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

    返回对象时，返回其 reference,可行？

    1. #include 
    2.  
    3. class Rational{
    4. public:
    5.     Rational(int numerator = 0, int denominator = 1)
    6.         :n(numerator),d(denominator){}
    7. private:
    8.     int n, d;
    9.     friend const Rational&
    10.     operator*(const Rational& lhs, const Rational& rhs);
    11. };
    12.  
    13. const Rational& operator*(const Rational& lhs,
    14.                           const Rational& rhs){
    15.     // local 变量，是在 stack 空间创建的
    16.     // 是不能作为返回值的
    17.     Rational result(lhs.n * rhs.n, lhs.d *rhs.d);
    18.     
    19.     
    20.     return result;
    21.  
    22. }
    23.  
    24. int main(int argc, char *argv[])
    25. {
    26.     Rational a(1,2);
    27.     Rational b(3,5);
    28.     Rational c = a * b;
    29.     return 0;
    30. }

    考虑在 heap 内构造一个对象，看能返回 referene，还是行不通:

    1. const Rational& operator*(const Rational& lhs,
    2.                           const Rational& rhs){
    3.     
    4.     // 考虑在 heap 内构造一个对象
    5.     Rational* result= new Rational(lhs.n * rhs.n, lhs.d *rhs.d);
    6.     return result;
    7.  
    8. }

    考虑使用 static 关键字：

    1. const Rational& operator*(const Rational& lhs,
    2.                           const Rational& rhs){
    3.  
    4.     // 定义一个在函数内部的 static Rational 对象
    5.     static Rational result = Rational(lhs.n * rhs.n, lhs.d *rhs.d);
    6.     return result;
    7.  
    8. }

    这次代码可用通过编译

    但是在书中这种写法也会在延伸点上出现问题。所以一个“必须返回新对象”的函数的正确写法是：就让那个函数返回一个新对象:

    1. const Rational operator*(const Rational& lhs,
    2.                           const Rational& rhs){
    3.  
    4.     // local 对象可以直接被返回，而不是返回其reference
    5.     Rational result = Rational(lhs.n * rhs.n, lhs.d *rhs.d);
    6.     return result;
    7.  
    8. }

    总结：

    绝不要返回 pointer 或 reference 指向一个 local stack 对象，或返回 reference 指向一个 heap-allocated对象，或返回 pointer 或 reference 指向一个local static 对象而有多个可能同时需要多和这样的对象。条款4已经为 “在单线程环境中合理返回 reference 指向一个 local static 对象”提供一份设计实例。

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

    一旦将一个成员变量声明为 public 或 protected 而客户开始使用它们，就很难改变那个成员变量所涉及的一切。太多代码需要重写、重新测试、重新编写文档、重新编译。从封装的角度观之，其实只有两种访问权限：priavate(提供封装)和其他（不提供封装）。

    请记住：

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

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

    1. #include 
    2.  
    3. class WebBrowser{
    4. public:
    5.     void clearCache();
    6.     void clearHistory();
    7.     void removeCookies();
    8.     
    9.     // 如果想一整个执行所有这些动作
    10.     // 方式一:
    11.     // 在类中提供这样一个函数，调用上面三个函数
    12.     void clearEveryThing();
    13. };
    14.  
    15. // 方式二： 
    16. // 也可以用一个non-member函数实现
    17. void clearBrowser(WebBrowser& wb){
    18.     wb.clearCache();
    19.     wb.clearHistory();
    20.     wb.removeCookies();
    21. }

    1、member 函数 clearEveryThing 带来的封装性比 non-member 函数 clearBrowser 低：

    • 对象内的数据，愈多函数可访问，数据的封装性就愈低

    2、降低编译依赖性

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

    先来看看何为隐式转换：

    1. #include 
    2.  
    3. class Rational {
    4. public:
    5.     // 构造函数刻意不为 explicit,
    6.     // 允许 int-to-Rational 隐式转换
    7.     Rational (int numerator = 0,
    8.              int denominator = 1)
    9.         :n(numerator),d(denominator){}
    10.  
    11.     // 分子（numerator）和 分母（denominator）的的访问函数
    12.     int numerator() const;
    13.     int denominator() const;
    14.  
    15. private:
    16.     int n,d;
    17. };
    18.  
    19. int main(int argc, char *argv[])
    20. {
    21.     // 这便是隐式转换：
    22.     // 【 将会隐式地将整数5转换为Rational类型，并通过调用构造函数
    23.     // Rational(int numerator = 0, int denominator = 1)来
    24.     // 创建Rational对象r。在这种情况下，numerator将被初始化为5，
    25.     // denominator将被初始化为1】
    26.     Rational r =5;
    27.  
    28.     return 0;
    29. }

    再来看看operator* 的使用会涉及到什么问题：

    1. #include 
    2.  
    3. class Rational {
    4. public:
    5.     // 构造函数刻意不为 explicit,
    6.     // 允许 int-to-Rational 隐式转换
    7.     Rational (int numerator = 0,
    8.              int denominator = 1)
    9.         :n(numerator),d(denominator){}
    10.  
    11.     // 分子（numerator）和 分母（denominator）的的访问函数
    12.     int numerator() const;
    13.     int denominator() const;
    14.  
    15.     const Rational operator* (const Rational& rhs) const{}
    16.  
    17. private:
    18.     int n,d;
    19. };
    20.  
    21.  
    22.  
    23.  
    24. int main(int argc, char *argv[])
    25. {
    26.     Rational oneEighth(1,8);
    27.     Rational oneHalf(1,2);
    28.     
    29.     Rational result = oneHalf * oneEighth;
    30.     result = result * oneEighth;
    31.     
    32.     
    33.     // 能运行
    34.     result = oneHalf * 2;
    35.     
    36.     // 错误！
    37.     result = 2 * oneHalf;
    38.  
    39.     return 0;
    40. }

    为啥 result = oneHalf * 2 可以运行， 而  result = 2 * oneHalf 却会报错：

    1、result = oneHalf * 2 发生了所谓隐式转换：

    oneHalf 是一个内含 operator* 函数的 class 的对象，所以编译器调用该函数。然后编译器知道你正在传递一个 int，而函数需要的是 Rational; 但它也知道只要调用 Rational 构造函数并赋予你所提供的 int，就可以变出一个适当的 Rational 来。于是它就这样做了。换句话说此一调用动作在编译器眼中有点像这样：

    1. const Ration temp(2); // 根据2建立一个暂时的 Rational 对象
    2. result = oneHalf * temp; // 等同于 oneHalf.operator*(temp)

    当然，只因为涉及到 non-explicit 构造函数，编译器才会这样做。如果 Rational 构造函数是 explicit ,以下语句没有一个能通过编译：

    1.  
    2.     result = oneHalf * 2;
    3.     
    4.  
    5.     result = 2 * oneHalf;

    2、result = 2 * oneHalf，整数2并没有相应的class,也就没有 operator* 成员函数。编译器也会尝试寻找可被以下这般调用的 non-member operator* （也就是在命名空间或在 global 作用域内）：

    result = operator*(2, oneHalf); // 错误

    但本例并不存在这样一个接受 int 和 Rational 作为参数的 non-member operator*，因此查找失败

    那怎么可以支持混合式算术运算。可行之道终于拨云见日：让 operator* 成为一个 non-member 函数， 便允许编辑器在每个实参身上执行隐式类型转换:

    1. #include 
    2.  
    3. class Rational {
    4. public:
    5.     // 构造函数刻意不为 explicit,
    6.     // 允许 int-to-Rational 隐式转换
    7.     Rational (int numerator = 0,
    8.              int denominator = 1)
    9.         :n(numerator),d(denominator){}
    10.  
    11.     // 分子（numerator）和 分母（denominator）的的访问函数
    12.     int numerator() const;
    13.     int denominator() const;
    14.  
    15. private:
    16.     int n,d;
    17. };
    18.  
    19. // 注意：参数是两个Rational对象的引用
    20. const Rational operator* (const Rational& lhs,
    21.                          const Rational& rhs) {}
    22.  
    23.  
    24. int main(int argc, char *argv[])
    25. {
    26.     Rational oneEighth(1,8);
    27.     Rational oneHalf(1,2);
    28.  
    29.     Rational result = oneHalf * oneEighth;
    30.     result = result * oneEighth;
    31.  
    32.  
    33.     // 能运行
    34.     result = oneHalf * 2;
    35.  
    36.     // 万岁，通过编译了！
    37.     result = 2 * oneHalf;
    38.  
    39.     return 0;
    40. }
    41.

    最后一个问题：operator* 是否应该成为 Rational class 的一个 friend  函数呢？

    就本例而言答案是否定的，因为 operator* 可以完全由 Rational 的 public 接口完成任务。这导出一个重要的观察：member 函数的反面是 non-member 函数，不是 friend 函数。

    无论任何时候可以避免 friend 函数就该避免。

    请记住：

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

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

    先来看看std::swap的典型实现：置换 a 和 b 的值

    1. namespace  std {
    2.     template<typename T>
    3.     void swap(T& a, T& b)
    4.     {
    5.         T temp(a); // a 复制到temp
    6.         a = b; // b 复制到 a
    7.         b = temp; // temp 复制到 b
    8.     }
    9. }

    只要类型 T 支持 copying (通过 copy 构造函数和 copy assignment 操作符完成)，缺省的 swap 实现代码就会帮你置换类型为 T 的对象。

    尝试将 std::swap 针对 Widget 特化:

    1. #include 
    2. #include 
    3.  
    4. class WidgetImp1{
    5. public:
    6. private:
    7.     int a,b,c;
    8.     std::vector<double> v;
    9. };
    10.  
    11. class Widget{
    12. private:
    13.     WidgetImp1* pImp1; // 一旦要置换
    14. public:
    15.     Widget(){}
    16.     Widget (const Widget& rhs){}
    17.     Widget& operator =(const Widget& rhs){
    18.         *pImp1 = *(rhs.pImp1);
    19.     }
    20. };
    21.  
    22.  
    23. // 一旦要置换两个 Widget 对象值，需要做的就是置换其pImp1指针。
    24. // 但缺省的 swap 算法 效率很低：
    25. // 不止复制三个 Widget, 还复制三个 WidgetWidgetImp1对象
    26. //
    27.  
    28. // 所以要告诉 std::swap:
    29. // 当 Widgets 被置换时真正该做的是置换其内部的pImp1指针
    30. // 所以，将 std::swap 针对 Widget 特化
    31. namespace  std {
    32.     template<>
    33.     void swap(Widget& a, Widget& b)
    34.     {
    35.     swap(a.pImp1, b.pImp1);
    36.     }
    37. }
    38.  
    39.  using namespace std;
    40.  
    41. int main(int argc, char *argv[])
    42. {
    43.     Widget a;
    44.     Widget b;
    45.  
    46.     std::swap(a,b);
    47.     return 0;
    48. }

    但是发现pImp1指针是私有变量，在类外访问不了

    所以要在类中定义一个swap成员函数，并在swap特化函数中 使用该函数：

    1. #include 
    2. #include 
    3.  
    4. class WidgetImp1{
    5. public:
    6. private:
    7.     int a,b,c;
    8.     std::vector<double> v;
    9. };
    10.  
    11. class Widget{
    12. private:
    13.     WidgetImp1* pImp1; // 一旦要置换
    14. public:
    15.     Widget(){}
    16.     Widget (const Widget& rhs){}
    17.     Widget& operator =(const Widget& rhs){
    18.         *pImp1 = *(rhs.pImp1);
    19.     }
    20.  
    21.     // 给swap 特化 所调用
    22.     void swap(Widget& other){
    23.         using std::swap;
    24.         swap(pImp1, other.pImp1);// 置换pImp1指针
    25.     }
    26. };
    27.  
    28.  
    29. // 一旦要置换两个 Widget 对象值，需要做的就是置换其pImp1指针。
    30. // 但缺省的 swap 算法 效率很低：
    31. // 不止复制三个 Widget, 还复制三个 WidgetWidgetImp1对象
    32. //
    33.  
    34. // 所以要告诉 std::swap:
    35. // 当 Widgets 被置换时真正该做的是置换其内部的pImp1指针
    36. // 所以，将 std::swap 针对 Widget 特化
    37. namespace  std {
    38.     template<>
    39.     void swap(Widget& a, Widget& b)
    40.     {
    41.         a.swap(b);
    42.     }
    43. }
    44.  
    45.  using namespace std;
    46.  
    47. int main(int argc, char *argv[])
    48. {
    49.     Widget a;
    50.     Widget b;
    51.  
    52.     std::swap(a,b);
    53.     return 0;
    54. }

    上面都是 class ，而非 class template。关于 class template 的 swap 函数暂时不学习。

    请记住：

    • 当 std::swap 对你的类型效率不高时，提供一个 swap 成员函数，并确定这个函数不抛出异常。
    • 如果你提供一个 member swap，也该提供一个non-member swap 用来调用前者。对于classes (而非 templates)，也清特化 std::swap.
    • 调用 swap 时应针对 std::swap 使用 using 声明式，然后调用 swap  并且不带任何 "命名空间资格修饰符”
    • 为“用户定义类型”进行 std templates 全特化是好的，但千万不要尝试在 std 内加入某些对 std 而言全新的东西

    五、实现

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

    过早定义变量的例子：

    1. #include 
    2. const int MininmumPasswordLength = 10;
    3.  
    4. std::string  encryptPassword(const std::string& password){
    5.     using namespace std;
    6.  
    7.     // 过早定义变量encrypted
    8.     // 如果下面抛出异常，该变量没用使用到
    9.     // 但还是要承受该变量的构造和析构成本
    10.     string encrypted;
    11.  
    12.     if (password.length() < MininmumPasswordLength){
    13.         throw logic_error("Password is too short");
    14.     }
    15.  
    16.     // 必要动作，便能将一个加密后的密码
    17.     // 置入变量 encrypted 内
    18.  
    19.     return encrypted;
    20. }

    最好延后 encrypted 的出现，直到真正需要它。

    但循环怎么办？

    如果变量只在循环内使用，那么把它定义于循环外并在每次循环迭代时赋值给它比较好，还是该把它定义于循环内？

    1. class Widget{};
    2. const int n;
    3.  
    4.  
    5. //A、 定义于循环外
    6. Widget w;
    7. for (int i=0; i
    8.     w = 取决于i的某个值;
    9. }
    10.  
    11. //B、 定义于循环内
    12. for (int i=0; i
    13.     Widget w = 取决于i的某个值;
    14. }

    两种写法的成本：

    做法A： 1个构造函数 + 1个析构函数 + n个赋值操作

    做法B：n个构造函数 + n个析构函数

    看情况而定！一般选B！

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

    旧式转型

    1. // C风格
    2. （T）expression // 将expression 转型为T
    3.  
    4. // 函数风格
    5. T（expression） //将expression转型为T

    新式转型

    1. // 用来将对象的常量性转除
    2. const_cast(expression)
    3.     
    4. // 安全向下转型
    5. dynamic_cast(expression)
    6.     
    7. // 低级转型，很少用
    8. reinterpret_cast(expression)
    9.     
    10. // 用来强迫转换
    11. static_cast(expression)

    旧式转型合法，但一般用新式转型：

    1、容易在代码中被辨识

    2、各转型动作的目标愈窄，编译器愈可能诊断出错误的运用

    唯一使用旧式转型的的时机是，当我要调用一个 explicit 函数将一个对象传递给一个函数时。例如：

    1. #include 
    2.  
    3. class Widget{
    4. public:
    5.     explicit Widget(int size){}
    6. };
    7.  
    8. void doSomeWork(const Widget& w){}
    9.  
    10. int main(int argc, char *argv[])
    11. {
    12.     // 以一个int加上“函数风格”的转型动作创建一个Widget
    13.     doSomeWork(Widget(15));
    14.     
    15.     // 以一个int加上“C++风格”的转型动作创建一个Widget
    16.     // 蓄意的“对象生成”动作感觉不怎么像“转型”，所以一般
    17.     // 用前者
    18.     doSomeWork(static_cast(15));
    19.     return 0;
    20. }

    这里避免用转型

    1. #include 
    2.  
    3. class Window{
    4. public:
    5.     virtual void onResize(){}
    6. };
    7.  
    8. class SpecialWindow: public Window{
    9. public:
    10.     virtual void onResize(){
    11.         // 避免这种写法
    12.         static_cast(*this).onResize();
    13.  
    14.         // 使用这种写法
    15.         Window::onResize(); // 调用Window::onResize 作用于*this身上
    16.  
    17.         // 这里写SpecialWindow专属行为
    18.         //。。。。。。。。。。。。。。
    19.     }
    20.  
    21. };
    22.  
    23. int main(int argc, char *argv[])
    24. {
    25.     SpecialWindow sw;
    26.     return 0;
    27. }

    dynamic_cast 比较耗时

    之所以需要dynamic_cast，通常时候因为你想在一个你认定为 derived class 对象身上执行 derived class 操作汉航速，但你手上却只有一个“指向base”的Pointer 或 referene, 你只能靠它们处理对象。

    省略。。。。。。。。。。

    请记住：

    如果可以，尽量避免转型，特别是在注重效率的代码中避免 dynamic_cast。如果有个涉及需要转型动作，试着发展无需转型的替代设计。

    如果转型式必要的，试着将他隐藏于某个函数背后。客户随后可以调用该函数，而不需要将转型放进他们自己的代码内。

    宁可使用C++-style（新式）转型，不要使用旧式转型。前者很容器辨识出来，而且也比较有着分门别类的职掌。

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

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. class Point{
    6. public:
    7.     Point(int a, int b):x(a),y(b){}
    8.     void setX(int newVal){}
    9.     void setY(int newVal){}
    10.  
    11.     int getX(){return x;}
    12. private:
    13.     int x,y;
    14. };
    15.  
    16. struct RectData
    17. {
    18.     Point leftTop;
    19.     Point rightDown;
    20. };
    21.  
    22. class Rectangle{
    23. private:
    24.     std::shared_ptr pData;
    25.  
    26. public:
    27.     // point 式自定义类型，根据条款20
    28.     // by-reference 更加高效
    29.     // 此时返回的式内部数据的引用，有被修改的风险
    30.     // 所以要前面要加上 const
    31.     const Point& upperLeft() const {return pData->leftTop;}
    32.     const Point& lowerRight() const {return pData->rightDown;}
    33.  
    34.     Rectangle(Point p1, Point p2){
    35.         pData->leftTop = p1;
    36.         pData->rightDown = p2;
    37.     }
    38. };

    本例中是成员函数返回 references,但如果它们返回的式指针或者迭代器也应该如此

    空悬号码牌的问题：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. class Point{
    6. public:
    7.     Point(int a, int b):x(a),y(b){}
    8.     void setX(int newVal){}
    9.     void setY(int newVal){}
    10.  
    11.     int getX(){return x;}
    12. private:
    13.     int x,y;
    14. };
    15.  
    16. struct RectData
    17. {
    18.     Point leftTop;
    19.     Point rightDown;
    20. };
    21.  
    22. class Rectangle{
    23. private:
    24.     std::shared_ptr pData;
    25.  
    26. public:
    27.     // point 式自定义类型，根据条款20
    28.     // by-reference 更加高效
    29.     // 此时返回的式内部数据的引用，有被修改的风险
    30.     // 所以要前面要加上 const
    31.     const Point& upperLeft() const {return pData->leftTop;}
    32.     const Point& lowerRight() const {return pData->rightDown;}
    33.  
    34.     Rectangle(Point p1, Point p2){
    35.         pData->leftTop = p1;
    36.         pData->rightDown = p2;
    37.     }
    38. };
    39.  
    40.  
    41. class GUIObject{};
    42. const Rectangle boundingBox(const GUIObject& obj){}
    43.  
    44.  
    45. int main(){
    46.     GUIObject* pgo;
    47.  
    48.     const Point* pUpperLeft = &(boundingBox(*pgo).upperLeft());
    49.  
    50. }

    本例子最后一句：

    boundingBox(*pgo)

    对 boundingBox 的调用获得一个新的、暂时的Rectangle 对象。这个对象没有名称，所以暂时称它为 temp。

    &boundingBox(*pgo).upperLeft()

    随后 upperLeft 作用于 temp 身上，返回一个 reference 指向 temp 的内部成分，更具体地说指向一个用以标识 temp 的 Points。于是pUpperLeft指向那个对象。

    但是在在那个语句结束后，boundingBox 的返回值，也就是我们所说的 temp，将被销毁，而那间接导致 temp 内的 Points 析构。最终导致 pUpperLeft  指向一个不再存在的对象；

    也就是说一旦产生 pUpperLeft 的那个语句结束，pUpperLeft 也就变成空悬、虚吊（dangling）

    但是我有个疑问：

    这里的shared_ptr怎么不需要分配内存？

    请记住：

    避免返回 handles (包括 references、指针、迭代器)指向对象内部。遵守这个条款可增加封装性，帮助 const 成员函数的行为像个 const，并将 “虚吊号码牌”（dangling handles）的可能性降至最低。

    条款29、为 " 异常安全 "而努力是值得的

    仔细分析下例ChangeBackground函数

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. struct Image
    6. {
    7.     char image[480*640];
    8. };
    9.  
    10. class PrettyMenu{
    11. public:
    12.     void ChangeBackground(Image& imgSrc);
    13.  
    14. private:
    15.     mutex mutex1;      // 互斥器
    16.     Image* bgImage;   // 目前的背景图像
    17.     int imageChanges; // 背景图像被改变的次数
    18. };
    19.  
    20.  
    21. void PrettyMenu::ChangeBackground(Image& imgSrc)
    22. {
    23.     mutex1.lock();               // 取得互斥器
    24.     delete bgImage;              // 摆脱旧的背景图像
    25.     ++imageChanges;              // 修改图像变更次数
    26.     bgImage = new Image(imgSrc); // 安装新的背景图像
    27.     mutex1.unlock();             // 释放互斥器
    28. }
    29.  
    30. int main(int argc, char *argv[])
    31. {
    32.     PrettyMenu pt;
    33.     return 0;
    34. }

    该函数可能会发生的问题：

    泄露资源：new Image(imgSrc) 导致异常，对 unlock 的调用就绝不会执行，于是互斥器就永远把持住了

    数据败坏：new Image(imgSrc) 抛出异常，bgImage就是指向一个已被删除的对象，imageChanges 也被累加，而其实并没有新的图像被成功安装起来

    泄露资源的问题如何解决：以对象管理资源

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. struct Image
    6. {
    7.     char image[480*640];
    8. };
    9.  
    10. class PrettyMenu{
    11. public:
    12.     void ChangeBackground(Image& imgSrc);
    13.  
    14. private:
    15.     mutex mutex1;      // 互斥器
    16.     Image* bgImage;   // 目前的背景图像
    17.     int imageChanges; // 背景图像被改变的次数
    18. };
    19.  
    20. void lock(mutex* pm){}
    21. void unlock(mutex* pm){}
    22.  
    23. class Lock{
    24. private:
    25.     mutex* mutexPtr;
    26. public:
    27.     explicit Lock(mutex* pm):mutexPtr(pm)
    28.     {
    29.         lock(mutexPtr);
    30.     }
    31.  
    32.     ~Lock()
    33.     {
    34.         unlock(mutexPtr);
    35.     }
    36. };
    37.  
    38.  
    39. void PrettyMenu::ChangeBackground(Image& imgSrc)
    40. {
    41.     Lock m1(&mutex1);            // 来自条款14：获得互斥器并确保它稍后被释放
    42.     delete bgImage;              // 摆脱旧的背景图像
    43.     ++imageChanges;              // 修改图像变更次数
    44.     bgImage = new Image(imgSrc); // 安装新的背景图像
    45.  
    46. }
    47.  
    48. int main(int argc, char *argv[])
    49. {
    50.     PrettyMenu pt;
    51.     return 0;
    52. }

    如此，利用对象管理资源！

    再来专注解决数据败坏，在解决该问题之前，先面对异常安全函数的三个保证：

    基本承诺：

    如果异常被抛出，程序内的任何事物仍然保持在有效状态下。没有任何对象或数据结构会因此而败坏，所有对象都处于一种内部前后一致的状态。举个例子，ChangeBackground 函数抛出异常后，PrettyMenu 对象仍然可以继续拥有原背景图像 ，或是令它拥有某个缺省背景图像。

    强烈保证：

    如果异常被抛出，程序状态不改变。调用这样的函数需有这样的认知：如果函数成功，就是完全成功，如果函数失败，程序会回复到 “调用之前的状态”。

    不抛掷保证：

    承诺绝不抛出异常，因为它们总是能够完成它们原先承诺的功能。

    异常安全码（Exception-safe code）必须提供上述三种保证之一，对于大部分函数往往在基本承诺和强烈保证中择一；

    怎么让 ChangeBackground 函数提供强烈保证：

    1. 用智能指针管理Image*
    2. 调整 ++imageChanges 到真的发生新背景图像安装之后
    1. class PrettyMenu{
    2.         ...
    3.         std::shared_ptr bgImage;
    4.         ...
    5. }
    6.  
    7. void PrettyMenu::ChangeBackground(Image& imgSrc)
    8. {
    9.     Lock m1(&mutex1);            
    10.  
    11.     bgImage.reset(new Image(imgSrc));// 以 “new Image” 的执行结果设定bgImage 内部指针
    12.  
    13.     ++imageChanges;              
    14.  
    15. }

    上述两个改变几乎足够让 ChangeBackground 提供强烈的异常安全保证。

    但是我们还想进一步。有一个一般化的设计策略很典型地会导致强烈保证，很值得熟悉。这个策略被称为--copy and swap：

    1、为你打算修改的对象（原件）做出一份副本，然后在那副本身上做一切必要修改。

    2、若有任何修改动作抛出异常，原对象仍保持未改变状态。

    3、待所有改变都成功后，再将修改过的那个副本和原对象在一个不抛出异常的操作中置换（swap）。

    实现上通常是将所有 “隶属对象的数据” 从原对象放进另一个对象内，然后赋予原对象一个指针，指向那个所谓的实现对象（implementation object，即副本）。这种手法常被称为 pimpl idiom，条款31 详细描述了它。典型的写法如下：

    1. // 将所有 “隶属对象的数据” 从原对象放进另一个对象内
    2. // 让 PMImpl 成为一个 struct 而不是 一个 class:
    3. // 1、PrettyMenu 的数据封装性已经由于 “pImpl是private” 而获得了保证
    4. // 2、如果令 PMImpl 为一个class，不是很方便 （条款25）
    5. struct PMImpl{
    6.     std::shared_ptr bgImage;
    7.     int imageChanges;
    8. };
    9.  
    10.  
    11. class PrettyMenu{
    12.     ...
    13. private:
    14.     mutex mutex1
    15.     // 赋予原对象一个指针
    16.     std::shared_ptr pImpl;
    17. };
    18.  
    19. void PrettyMenu::ChangeBackground(Image& imgSrc)
    20. {
    21.     using std::swap;   // 见条款25
    22.     Lock m1(&mutex1);
    23.  
    24.     // 创建副本
    25.     // 感觉应该写成下面这个：
    26.     //std::shared_ptr pNew(new PMImpl(*pImpl));
    27.  
    28.     std::shared_ptr pNew(new PMImpl);
    29.     
    30.     // 修改副本
    31.     pNew->bgImage.reset(new Image(imgSrc)); 
    32.     ++pNew->imageChanges;
    33.     
    34.     // 置换（swap）数据
    35.     swap(pImpl, pNew); 
    36. }

    本例中，借以 “copy-and-swap” 策略 对对象状态实现 "全有或全无"。

    清记住：

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

    2、“强烈保证” 往往能够以 copy-and-swap 实现出来，但 “强烈保证”并非对所有函数都可实现或具备现实意义。

    3、函数提供的 “异常安全保证” 通常最高只等于其所调用之各个函数的 “异常安全保证” 中的最弱者

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

    inline 关键字的作用：

    inline 关键字用于修饰函数，它是一种对编译器的建议，用于告诉编译器在编译时将函数内联展开。

    通常情况下，函数的调用会导致程序跳转到函数的定义处执行，然后再返回到调用点。当函数较小且频繁调用时，这种跳转和返回的开销可能会成为性能瓶颈。

    使用 inline 关键字可以建议编译器将函数的定义插入调用点，而不是跳转到函数的定义处执行。这样可以减少函数调用的开销，提高程序的执行效率。

    要声明一个内联函数，只需在函数定义的前面加上 inline 关键字即可。例如：

    1. inline int add(int x, int y) {
    2.     return x + y;
    3. }

    需要注意的是，inline 关键字只是对编译器的建议，编译器可以选择是否将函数内联展开。通常情况下，对于较短的函数，编译器会选择内联展开。但是对于较长的函数，编译器可能会忽略 inline 关键字的建议。

    另外，将函数定义放在头文件中时，为了避免出现多重定义错误，通常需要将函数声明为 inline。因为头文件会被多个源文件包含，如果函数定义不是 inline 的，则每个源文件中都会有一份函数定义，从而导致多重定义错误。

    直接在 class 定义式内呈现成员函数的本体，会让该成员函数暗自成了inline 。

    请记住：

    1、将大多数 inlining 限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级（binary upgradability） 更容易，也可以使潜在的代码膨胀问题最小化，使程序的速度提升机会最大化。

    2、不要只因为 function templates 出现在头文件中，就将它们声明为 inline

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

    在了解文件间的编译依存关系之前，先来看看这个例子：

    1.  
    2.  
    3. class Person{
    4. public:
    5.     Person(const std::string& name, const Date& birthday,
    6.            const Address& addr){}
    7.  
    8.     std::string name() const;
    9.     std::string birthday() const;
    10.     std::string address() const;
    11.  
    12. private:
    13.     std::string theName;      //
    14.     Date theBirthData;
    15.     Address theAddress;
    16. };
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20.     std::string name;
    21.     Date birthday;
    22.     Address addr;
    23.  
    24.     Person p(name, birthday, addr);
    25.     return 0;
    26. }

    没错，这个例子根本就无法通过编译，因为编译器没有取得其实现代码所用到的 classes string, Data 和 Address的定义式。

    这样的定义式通常由 #include 指示符提供，所以 Person 定义文件的最上方很可能存在这样的的东西：

    1. #include 
    2. #include "data.h"
    3. #include "address.h"

    但是这样一来，Person 定义文件和其含入文件之间形成了一种编译依存关系。

    现在需要 “将对象实现细目隐藏于一个指针背后”。正对 Person 可以这样做： 把 Person 分割成两个 classes，一个只提供接口，另一个负责实现该接口。如果负责实现的那个所谓 implementation class 取名为 PersonImpl，Person 将定义如下：

    1. #include 
    2. #include 
    3.  
    4.  
    5. // Person 实现类的前置声明
    6. class PersonImpl{};
    7.  
    8. //Person 接口用到的 classes 的前置声明
    9. class Date{};
    10. class Address{};
    11.  
    12.  
    13. class Person{
    14. public:
    15.     Person(const std::string& name, const Date& birthday,
    16.            const Address& addr){}
    17.  
    18.     std::string name() const;
    19.     std::string birthday() const;
    20.     std::string address() const;
    21.  
    22. private:
    23.     // 指针，指向实现物
    24.     // 以对象管理资源，条款13
    25.     std::shared_ptr pImpl;
    26. };
    27.  
    28. int main(int argc, char *argv[])
    29. {
    30.     std::string name;
    31.     Date birthday;
    32.     Address addr;
    33.  
    34.     Person p(name, birthday, addr);
    35.     return 0;
    36. }

    在这里，main class(Person) 只内含一个指针成员（这里使用std::shared_ptr,见条款13），指向其实现类（PersonImpl）。这般设计常被称为 pimpl idiom(pimpl 是 “pointer to implementation”的缩写)。这种 classes 内的指针名称往往就是pImpl，就像上面代码那样。

    这样的设计之下，Person的客户就完全与 Dates,Addresses 以及 Persons 的实现细目分离。那些classes 的任何实现修改都不需要 Person 客户端重新编译。这样就是“接口与实现分离”。

    这个分离的关键在于以“声明的依存性”替换“定义的依存性”，那正是编译依存性最小化的本质：现实中让头文件尽可能自我满足，万一做不到，则让它与其他文件内的声明式（而非定义式）相依。其他每一件事都源自于这个简单的设计策略：

    1、如果使用 object reference 或 objecct pointers 可以完成任务，就不要使用 objects。

    2、如果能够，尽量以 class 声明式替换 class 定义式。

    3、为声明式和定义式提供不同的头文件，一个用于声明式，一个用于定义式。

    像person这样使用 pimpl idiom 的 classes，往往被成为 Handle classes。

    另一个制作 Handle class 的办法式，令 Person 成为一种特殊的 abstract base class(抽象基类)，称为 Interface class。

    这个例子有问题：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. // 一个针对Person而写的 Interface class （抽象基类）
    6. // 目的：
    7. // 详细描述 derived classes 的接口（见条款34）
    8. // 所以通常不带成员变量，也没有构造函数，
    9. // 只有一个virtual 析构函数以及一组 pure virtual 函数，
    10. // 用来叙述整个接口
    11.  
    12. class Date{};
    13. class Address{};
    14. class Person{
    15. public:
    16.     virtual ~Person();
    17.     virtual std::string name() const=0;
    18.     virtual std::string birthDate() const = 0;
    19.     virtual std::string address() const = 0;
    20.  
    21.     static std::shared_ptr create(const std::string& name,
    22.                                           const Date& birthDate,
    23.                                           const Address& addr);
    24.  
    25. };
    26.  
    27. class RealPerson: public Person{
    28. private:
    29.     std::string theName;
    30.     Date theBirthDate;
    31.     Address theAddress;
    32. public:
    33.     RealPerson(const std::string& name, const Date& birthday,
    34.                 const Address& addr)
    35.         :theName(name),theBirthDate(birthday),theAddress(addr){}
    36.  
    37.     virtual ~RealPerson() {}
    38.  
    39.  
    40.     std::string name() const{}
    41.     std::string birthDate() const{}
    42.     std::string address() const{}
    43. };
    44.  
    45. std::shared_ptr Person::create(const std::string &name,
    46.                                        const Date &birthDate,
    47.                                        const Address &addr)
    48. {
    49.     return
    50.         std::shared_ptr(new RealPerson(name,birthDate,addr));
    51. }
    52.  
    53. int main(){
    54.  
    55.     std::string name;
    56.     Date dateOfBirth;
    57.     Address address;
    58.  
    59.     std::shared_ptr pp(Person::create(name, dateOfBirth, address));
    60.  
    61.     std::cout << pp->name() << " was born on "
    62.               << pp->birthDate() << " and now lives at "
    63.               << pp->address();
    64. }

    请记住：

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

    2、程序库头文件应该式以 “完全且仅有声明式”的形式存在。这种做法不论是否涉及 templates 都适用。

    六、继承与面向对象设计

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

    请记住：

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

    条款33、避免遮挡继承而来的名称

    看看这个例子：

    1. #include 
    2.  
    3. int x= 1; // global 变量
    4.  
    5. void someFunc()
    6. {
    7.     double x=2.3; // local 变量
    8.     std::cout << x << '\n';
    9. }
    10.  
    11. int main(int argc, char *argv[])
    12. {
    13.     someFunc();
    14.     return 0;
    15. }

     

    看见没，打印的是2.3。是 local 变量 x, 而不是 global 变量 x，因为内层作用域的名称会遮掩（遮蔽）外围作用域的名称。没错即使类型不一样，也会被遮蔽，只看变量名称！

    在类继承中呢？

    1. #include 
    2.  
    3. class Base{
    4. private:
    5.     int x;
    6. public:
    7.     virtual void mf1()=0;
    8.     virtual void mf1(int){}
    9.     virtual void mf2(){}
    10.     void mf3(){}
    11.     void mf3(double){}
    12. };
    13.  
    14. class Derived: public Base{
    15. public:
    16.     virtual void mf1(){}
    17.     void mf3(){}
    18.     void mf4(){}
    19. };
    20.  
    21. int main(){
    22.     Derived d;
    23.     int x;
    24.  
    25.     d.mf1();             // 调用 Derived::mf1
    26.     d.mf1(x); // 错误！因为 Derived::mf1 遮掩了 Base::mf1
    27.  
    28.     d.mf2();             // 调用 Base::mf2
    29.  
    30.     d.mf3();             // 调用 Derived::mf3
    31.     d.mf3(x); // 错误! 因为 Derived::mf3 遮掩了 Base::mf3           
    32. }

     如本例所见，即使 base classes 和 derived classes 内的函数有不同的参数类型也适用，而且不论函数是 virtual 或 non-virtual 一体适用。只要函数名字相同，继承类就会遮掩掉基类的函数。

    当然，也有办法在扩展类中调用基类被遮掩的函数：

    方法一：使用using 声明式

    1. #include 
    2.  
    3. class Base{
    4. private:
    5.     int x;
    6. public:
    7.     virtual void mf1()=0;
    8.     virtual void mf1(int){}
    9.     virtual void mf2(){}
    10.     void mf3(){}
    11.     void mf3(double){}
    12. };
    13.  
    14. class Derived: public Base{
    15. public:
    16.     // 让Base class 内名为mf1和mf3的所有东西在Derived作用域内都可见（并且public）
    17.     using Base::mf1;
    18.     using Base::mf3;
    19.  
    20.     virtual void mf1(){}
    21.     void mf3(){}
    22.     void mf4(){}
    23. };
    24.  
    25. int main(){
    26.     Derived d;
    27.     int x=1;
    28.  
    29.     d.mf1();             // 调用 Derived::mf1
    30.     d.mf1(x); // 现在可以了
    31.  
    32.     d.mf2();             // 调用 Base::mf2
    33.  
    34.     d.mf3();             // 调用 Derived::mf3
    35.     d.mf3(x); // 现在可以了
    36. }

    方法二：使用转交函数（forwarding functions)

    请记住：

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

    为了被遮掩的名称再见天日，可使用 using 声明式或转交函数（forwarding functions）

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

    1. #include 
    2.  
    3. class Shape{
    4. public:
    5.     virtual void draw() const = 0;
    6.     virtual void error(const std::string& msg);
    7.     int objectID() const;
    8. };
    9.  
    10. class Rectangle : public Shape{
    11.     void draw() const{}
    12. };
    13. class Ellipse : public Shape{
    14.     void draw() const{}
    15. };
    16.  
    17. int main(){
    18.     // 错误！ Shape 是抽象的，不能实例化
    19.     Shape* ps = new Shape;
    20.  
    21.     Shape* ps1 = new Rectangle;
    22.     ps1->draw();// 调用 Rectangle::draw
    23.  
    24.     Shape* ps2 = new Ellipse;
    25.     ps2->draw(); // 调用 Ellipse::draw
    26.  
    27.     // 调用Shape::draw
    28.     // 但是没有什么意义，因为纯虚函数在基类中根本没有定义
    29.     ps1->Shape::draw();
    30.     ps2->Shape::draw();
    31. }

    声明简朴的（非纯）impure virtual 函数的目的，是让 derived classes 继承该函数的接口和缺省实现：

    比如

    1. class Shape{
    2. public:
    3. virtual void error(const std::string& msg);
    4. }

    你必须支持一个 error 函数，但如果你不想自己写一个，可以使用 Shape class 提供的缺省版本

    再看一个例子：

    1.  
    2. class Airport{};
    3. class Airplane{
    4. public:
    5.     virtual void fly(const Airport& destination);
    6. };
    7.  
    8. void Airplane::fly(const Airport& destination){
    9.     // 缺省代码，将飞机飞到指定的目的地
    10. }
    11.  
    12. class ModelA : public Airplane{};
    13. class ModelB : public Airplane{};

    为了避免在ModelA 和 ModelB 中撰写相同代码，缺省飞行行为由 Airplane::fly 提供，它同时被 ModelA 和 ModelB 继承。

    这是个典型的面向对象设计。两个 class 共享一份相同性质（也就是它们实现 fly的方式），所以共同性质被搬到 base class 中。

    如果有一个新的类 ModelC也继承 Airplane，但是飞行动作和缺省的不一样，如果忘记重载飞机动作的话，在调用飞行动作的时候就会不可避免的使用基类的飞行动作，而这会导致错误。

    1. class Airport{};
    2.  
    3. class Airplane{
    4. public:
    5.     virtual void fly(const Airport& destination);
    6. };
    7.  
    8. void Airplane::fly(const Airport& destination){
    9.     // 缺省代码，将飞机飞到指定的目的地
    10. }
    11.  
    12. class ModelA : public Airplane{};
    13. class ModelB : public Airplane{};
    14.  
    15. class ModelC: public Airplane{
    16.  
    17.     // 未声明fly函数
    18. };
    19.  
    20. int main(int argc, char *argv[])
    21. {
    22.     Airport PDX;
    23.  
    24.     Airplane* pa = new ModelC;
    25.     
    26.     // 
    27.     pa->fly(PDX);
    28.  
    29.     delete pa;
    30.     return 0;
    31. }

    那有什么方法，避免上述问题？

    方法一：切断 “virtual 函数接口”和其 “缺省实现之间的连接”

    1. #include 
    2.  
    3. class Airport{};
    4.  
    5. class Airplane{
    6. public:
    7.     virtual void fly(const Airport& destination) = 0;
    8.  
    9.  
    10. protected:
    11.     // 这个不是接口，是用于接口的缺省代码
    12.     // 所以是protected,
    13.     // 继承类也可以访问该函数
    14.     void defaultFly(const Airport& destination);
    15. };
    16.  
    17. void Airplane::defaultFly(const Airport& destination){
    18.     // 缺省代码，将飞机飞到指定的目的地
    19. }
    20.  
    21. class ModelA : public Airplane{
    22. public:
    23.     virtual void fly(const Airport &destination)
    24.     {defaultFly(destination);}
    25. };
    26.  
    27. class ModelB : public Airplane{
    28. public:
    29.     virtual void fly(const Airport &destination)
    30.     {defaultFly(destination);}
    31. };
    32.  
    33. class ModelC: public Airplane{
    34. public:
    35.     // 现在不可能意外继承不正确的fly实现代码了
    36.     // 因为 Airplane中的pure virtual 函数迫使ModelC 必须提供自己的fly版本
    37.     virtual void fly(const Airport &destination){}
    38.  
    39.  
    40. };
    41.  
    42. int main(int argc, char *argv[])
    43. {
    44.     Airport PDX;
    45.  
    46.     Airplane* pa = new ModelA;
    47.  
    48.     //
    49.     pa->fly(PDX);
    50.  
    51.     delete pa;
    52.     return 0;
    53. }

    如果你不喜欢 以不同的函数分别提供接口和缺省实现，像上述的 fly 和 defaultFly 那样。

    方法二：

    pure virtual 函数必须在 derived classes 中重新声明，但它们也可以拥有自己的实现

    1. #include 
    2.  
    3. class Airport{};
    4.  
    5. class Airplane{
    6. public:
    7.     virtual void fly(const Airport& destination)=0;
    8.  
    9. };
    10.  
    11. void Airplane::fly(const Airport& destination){
    12.     // 缺省代码，将飞机飞到指定的目的地
    13. }
    14.  
    15. class ModelA : public Airplane{
    16. public:
    17.     virtual void fly(const Airport &destination)
    18.     {Airplane::fly(destination);}
    19. };
    20.  
    21. class ModelB : public Airplane{
    22. public:
    23.     virtual void fly(const Airport &destination)
    24.     {Airplane::fly(destination);}
    25. };
    26.  
    27. class ModelC: public Airplane{
    28. public:
    29.  
    30.     virtual void fly(const Airport &destination);
    31. };
    32.  
    33. void  ModelC::fly(const Airport &destination){
    34.     // 将C型飞机飞至指定的目的地
    35. }
    36.  
    37. int main(int argc, char *argv[])
    38. {
    39.     Airport PDX;
    40.  
    41.     Airplane* pa = new ModelA;
    42.  
    43.     //
    44.     pa->fly(PDX);
    45.  
    46.     delete pa;
    47.     return 0;
    48. }

    纯虚函数也可以有定义！

    声明 non-virtual 函数的目的是为了令 dedrived classes 继承函数的接口及一份强制性实现：

    每个扩展类都必须有这个non-virtual 函数

    pure virtual函数、simple(impure) virtual 函数、 non-virtual 函数之间的差异，使得你得以精确指定你想要 derived classes 继承的东西：之继承接口，或是继承接口和一份缺省实现，或是继承接口和一份强制实现

    请记住：

    1、接口继承和实现继承不同。在Public 继承之下，derived classes 总是继承 base class 的接口

    2、pure virtual 函数只具体指定接口继承

    3、简朴的（非纯）impure virtual 函数具体指定接口继承以及缺省实现继承

    4、non-virtual 函数具体指定接口继承以及强制性实现继承

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

    healthValue 并为被声明 pure virtual，这暗示我们将会有个计算健康指数的缺省算法（见条款34）

    1. class GameCharacter{
    2. public:
    3.     virtual int healthValue() const;
    4. }

    还有其他方法：

    借由 Non-Virtual Interface 手法实现 Template Method 模式：

    1. class GameCharacter{
    2. private:
    3.     virtual int doHealthValue() const{
    4.         // 缺省算法，计算健康指数
    5.     }
    6.  
    7. public:
    8.     // derived classes 不重新定义它，见条款36
    9.     // 在class 定义式内呈现成员函数本体，会让其暗自成为inline,条款30
    10.     int healthValue() const{
    11.         // 做一些事前工作，
    12.  
    13.         // 做真正的工作
    14.         int retValue =  doHealthValue();
    15.  
    16.         // 做一些事后的工作
    17.  
    18.         return retValue;
    19.     }
    20. }

    借由 Function Pointers 实现 Strategy 模式：

    书上的代码表述不清楚

    省略。。。。

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

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

    virtual 函数系动态绑定（dynamically bound），而缺省参数值却是静态绑定（statically bound）。

    这句话是不是看起来不好理解，先来看看动态绑定和静态绑定式什么意思：

    1. // 一个用以描述几何形状的 class
    2. class Shape{
    3. public:
    4.     enum ShapeColor{Red, Green, Blue};
    5.  
    6.     // 所有形状都必须提供一个函数，用来绘出自己
    7.     virtual void draw(ShapeColor color = Red) const =0;
    8. };
    9.  
    10. class Rectangle: public Shape{
    11. public:
    12.     // 赋予不同的缺省参数值。这真糟糕
    13.     virtual void draw(ShapeColor color = Green) const{
    14.         std::cout << "color: " << color << '\n';
    15.     }
    16. };
    17.  
    18. class Circle: public Shape{
    19. public:
    20.     // 以对象调用此函数，一定要指定参数值
    21.     // 因为静态绑定下这个函数并不从其base继承缺省参数值
    22.  
    23.     // 但若以指针（或reference）调用此函数，可以并不指定参数值
    24.     // 因为动态绑定下这个函数会从其base继承缺省参数值
    25.     virtual void draw(ShapeColor color) const{
    26.         std::cout << "color: " << color << '\n';
    27.     }
    28. };
    29.  
    30. int main(){
    31.     // ps、pc、pr 被声明为 pointer-to-Shape类型
    32.     // 所以不论它们真正指向什么，它们的静态类型都是 Shape*
    33.     Shape* ps;
    34.     Shape* pc = new Circle;
    35.     Shape* pr = new Rectangle;
    36.     
    37.     // 对象的所谓动态类型则是指：
    38.     // “目前所指对象的类型”
    39.     // 所以：
    40.     // pc 的动态类型是 Circle*
    41.     // pr 的动态类型是 Rectangle*
    42.     // ps 没有动态类型，因为它尚未指向任何对象
    43.     
    44.  
    45.     Circle c;
    46.     c.draw(); // 错误！没有指定参数值
    47.     
    48.     ps = pc; // ps的动态类型如今是 Circle*
    49.     ps = pr;
    50. }

    Virtual 函数系动态绑定，意思是调用一个Virtual 函数时，究竟调用哪一份函数实现代码，取决于发出调用的那个对象的动态类型

    1.     pc->draw(Shape::Red); // 调用Circle::draw(Shape::Red)
    2.     pr->draw(Shape::Red); // 调用 Rectangle::draw(Shape::Red)

    缺省参数值是静态绑定。意思是你可能会在“调用一个定义于dereived class 内的函数”的同时，却使用 base class 为它指定的缺省参数值

    1.     // 调用Rectangel::draw(Shape::Red)
    2.     // 是的，你没看错参数是Shape::Red
    3.     // 而不是在Rectangle里重新定义的Shape::Green
    4.     pr->draw();

        即使把指针换成references问题仍然存在。问题在于draw 是个 virtual 函数，而它有个缺省参数值 在 derived class 中被重新定义了。

    当你想令 virtual 函数表现出你所想要的行为但却遭遇麻烦，聪明的做法是考虑替代设计。条款35中，NVI（non-virtual interface）手法：令 base class 内的一个 public non-virtual 函数调用 private virtual 函数，后者可被 derived classes 重新定义。这里我们可以让 non-virtual 函数指定缺省参数，而 private virtual 函数负责真正的工作：

    1. #include 
    2.  
    3.  
    4. // 一个用以描述几何形状的 class
    5. class Shape{
    6. public:
    7.     enum ShapeColor{Red, Green, Blue};
    8.     void draw(ShapeColor color = Red) const{  // 如今它是non-virtual
    9.          doDraw(color);                       // 调用一个virtual
    10.     }
    11.  
    12. private:
    13.     // 真正的工作在此完成
    14.     virtual void doDraw(ShapeColor color) const=0;
    15. };
    16.  
    17.  
    18. class Rectangle : public Shape{
    19. public:
    20.  
    21. private:
    22.     // 注意，不须指定缺省参数值
    23.  
    24.     // 就算你这里重新定义了缺省参数，也没有用
    25.     // 因为non-vitual 函数应该绝对不被 derived classes 覆写（条款36）
    26.     // 这个设计很清楚地使得 draw 函数的color 缺省参数总是为Red
    27.     virtual void doDraw(ShapeColor color) const{
    28.          std::cout << "color:" << color << '\n';
    29.     }
    30. };
    31.  
    32. int main(){
    33.     Shape* r = new Rectangle;
    34.     r->draw();
    35.     delete r;
    36.  
    37.     // 即使以对象调用此函数，也不需要指定参数值
    38.     Rectangle r1;
    39.     r1.draw();
    40. }

    请记住：

    绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而 virtual 函数---- 你唯一应该覆写的东西---却是动态绑定。

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

    1. #include 
    2. #include 
    3.  
    4.  
    5. template<class T>
    6. class Set{
    7. public:
    8.     bool member(const T& item) const;
    9.     void insert(const T& item);
    10.     void remove(const T& item);
    11.     std::size_t size() const;
    12.  
    13. private:
    14.     std::list rep;
    15. }
    16.  
    17. template<typename T>
    18. bool Set::member(const T &item) const
    19. {
    20.     return std::find(rep.begin(), rep.end(), item) != rep.end()
    21. }
    22.  
    23.  
    24. template<typename T>
    25. bool Set::insert(const T &item)
    26. {
    27.     if (!member(item)) rep.push_back(item);
    28. }
    29.  
    30. template<typename T>
    31. void Set::remove(const T &item)
    32. {
    33.     typename std::list::iterator it =
    34.         std::find(rep.begin(), rep.end(), item);
    35.     if (it != rep.end()) rep.erase(it);
    36. }
    37.  
    38. template<typename T>
    39. std::size_t Set::size() const
    40. {
    41.     return rep.size();
    42. }

    请记住：

    复合的意思和 public 继承完全不同

    在应用域，复合意味着 has-a, 在实现域，复合意味着更具某物实现出 

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

    看完这个例子后，你是否理解是否要谨慎使用 private 继承：

    1. #include 
    2.  
    3. class Person{};
    4. class Student: private Person{};
    5. void eat(const Person& p);
    6. void study(const Student& s);
    7.  
    8.  
    9. int main(){
    10.     Person p;
    11.     Student s;
    12.  
    13.     eat(p);
    14.  
    15.     // 错误！
    16.     // classes之间的继承关系是private
    17.     // 编译器不会自动将一个derived class 对象转换为一个 base  class 对象
    18.     // 这确实与 public 继承不一样
    19.  
    20.     // 第二条规则：
    21.     // 由 private base 继承而来的所有成员，在 derived class 中都会变成 private 属性，
    22.     // 纵使它们在 base class 中原来是 protected 或 public 属性
    23.  
    24.     eat(s);
    25. }

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

    一个简单的多重继承的例子：

    1. #include 
    2.  
    3. class BorrowableItem{ // 图书光允许你借某些东西
    4. public:
    5.     void checkOut(){} // 离开时进行检查
    6. };
    7.  
    8. class ElectronicGadget{
    9. private:
    10.     bool checkOut() const{} // 执行自我检测，返回是否检测成功
    11. };
    12.  
    13. class MP3Player:
    14.     public BorrowableItem,
    15.     public ElectronicGadget{};
    16.  
    17.  
    18. int main(){
    19.     MP3Player mp;
    20.  
    21.     // 有歧义，不知道是用那个基础类的
    22.     mp.checkOut();
    23.  
    24.     // 应该这样
    25.     mp.BorrowableItem::checkOut();
    26. }

    再复杂一点，一个钻石型多重继承:

    1. #include 
    2. #include 
    3.  
    4. class File{
    5. public:
    6.     std::string fileName = "jason";
    7. };
    8.  
    9. class InputFile : public File{};
    10.  
    11. class OutFile : public File{};
    12.  
    13. class IOFile : public InputFile,
    14.                public OutFile{};
    15.  
    16. int main(){
    17.     IOFile io;
    18.  
    19.     std::cout << io.fileName << '\n';
    20. }

    File class 有个成员变量 fileName,但是 IOFile  从其每一个 base class 继承一份，所以其应该有两份 fileName 成员变量。所以导致有歧义！

    解决方法是：直接继承 File 的 classes 采用 “virtual 继承”

    1. class File{
    2. public:
    3.     std::string fileName = "jason";
    4. };
    5.  
    6. class InputFile : virtual public File{};
    7.  
    8. class OutFile : virtual public File{};
    9.  
    10. class IOFile : public InputFile,
    11.                public OutFile{};

    其他省略

    七、模板与泛型编程

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

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

    以下 template 声明式，class 和 typename 意义完全相同：

    1. template<class T> class Widget;
    2. template<typename T> class Widget;

    其实下面个例子运行不起来。

    1. #include 
    2. #include 
    3. // 下述 template function 接受一个STL兼容容器作为参数
    4. template<typename C>
    5. void prinr2nd(const C& container){ // 打印容器内的第二个元素
    6.     if (container.size() >= 2){
    7.         C::const_iterator iter(container.begin()); // 取得第一元素的迭代器
    8.         ++iter;  // 将 iter 移往第二元素
    9.         int value = *iter; // 将该元素复制到某个int
    10.         std::cout << value; // 打印那个int
    11.     }
    12. }
    13.  
    14.  
    15. int main(int argc, char *argv[])
    16. {
    17.     std::vector p{1,2,3,4};
    18.     prinr2nd(p);
    19.     return 0;
    20. }

    这是解决办法：

    1. #include 
    2. #include 
    3. // 下述 template function 接受一个STL兼容容器作为参数
    4. template<typename C>
    5. void prinr2nd(const C& container){ /
    6.     if (container.size() >= 2){
    7.         
    8.         //iter 的类型是 C::const_iterator，实际是什么必须取决于 template 参数C
    9.         // template 内出现的名称如果相依某个 template 参数，称之为从属名称（dependent names）
    10.         // 如果从属名称在class内呈嵌套状，我们称为嵌套从属名称（nested dependent name）
    11.         
    12.         // C::const_iterator 就是这样嵌套从属类型名称，所以必须以template 为前导
    13.         
    14.         typename C::const_iterator iter(container.begin()); 
    15.         ++iter;  
    16.         int value = *iter; 
    17.         std::cout << value; 
    18.     }
    19. }
    20.  
    21.  
    22. int main(int argc, char *argv[])
    23. {
    24.     std::vector p{1,2,3,4};
    25.     prinr2nd(p);
    26.     return 0;
    27. }

    当然也有例外，但暂不学习

    在真实程序的代表性例子：

    1. template<typename IterT>
    2. void workWithIterator(IterT iter){
    3.     typename std::iterator_traits::value_type temp(*iter);
    4. }
    5.  
    6.  
    7. // 如果你认为 std::iterator_traits::value_type 读起来不畅快
    8. // 可以考虑建立一个 typedef
    9. template<typename IterT>
    10. void workWithIterator(IterT iter){
    11.     typedef typename std::iterator_traits::value_type value_type;
    12.     value_type    temp(*iter);
    13. }

    请记住：

    声明template 参数时，前缀关键字 class 和 typename  可互换

    请使用关键字 typename 标识嵌套从属类型名称；但不得在 base class lists(基类列)或member initialization list (成员初值列)内以它作为 base class 修饰符。

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

    看这个不能通过编译的例子：

    1. #include 
    2. #include 
    3.  
    4. class CompanyA{
    5. public:
    6.     void sendCleartext(const std::string& msg);
    7.     void sendEncrypted(const std::string& msg);
    8. };
    9. class CompanyB{
    10. public:
    11.     void sendCleartext(const std::string& msg);
    12.     void sendEncrypted(const std::string& msg);
    13. };
    14.  
    15. class MsgInfo{};
    16.  
    17. template<typename Company>
    18. class MsgSender{
    19. public:
    20.     void sendClear(const MsgInfo& info)
    21.     {
    22.         std::string msg;
    23.         // 在这里，根据 info 产生信息
    24.  
    25.         Company c;
    26.         c.sendCleartext(msg);
    27.     }
    28.  
    29.     void sendSecret(const MsgInfo& info)
    30.     {}
    31. };
    32.  
    33.  
    34. template<typename Company>
    35. class LoggingMsgSender: public MsgSender{
    36. public:
    37.     void sendClearMsg(const MsgInfo& info)
    38.     {
    39.         // 将“传送前”的信息写至log:
    40.  
    41.  
    42.         // 调用 base class 函数； 这段无法通过编译
    43.         // 问题在于:
    44.         // 当编译器遭遇 class template LoggingMsgSender 定义式时，并不知道它继承什么样的class
    45.         // 当然它继承的是 MsgSender,但其中的Company是个是个template参数，
    46.         // 不到后来（当 LoggingMsgSender 被具体化）无法确切知道它是什么。
    47.         // 而如果不知道 Company 是什么，就无法知道 class MsgSender看起来像什么
    48.         // 更确切地说是没办法知道它是否有个 sendClear 函数
    49.         sendClear(info);
    50.  
    51.  
    52.         // 将“传送后”的信息写至log
    53.     }
    54. };
    55.  
    56.  
    57. int main(){
    58.     MsgSender m;
    59. }

    解决之道：针对 某个Company 产生一个MsgSender 特化版：

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

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

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

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

    条款48、认识template 元编程

    八、定制 new 和 delete

    条款49、 了解 new-handler 的行为

    通过本例了解 new-handler:

    1. #include 
    2.  
    3.  
    4. // 以下是 operator new 无法分配足够内存时，该被调用的函数
    5. void outOfMem(){
    6.     std::cerr << "Unable to satisfy request for memory\n";
    7.     std::abort();
    8. }
    9.  
    10. int main(){
    11.     std::set_new_handler(outOfMem);
    12.     int* pBigDataArray = new int[10000000000000000000000];
    13.  
    14.     delete pBigDataArray;
    15. }

    看见没，在崩溃前有报错信息了！！

    一个设计良好的 new-handler 函数必须做的事情：

    1、让更多内存可被使用：

    当程序一开始执行就分配一大块内存，而后当new-handler 第一次被调用，将它们释还给程序使用

    2、安装另一个new-handler

    3、卸除 new-handler

    4、抛出 bad_alloc 的异常

    5、不返回，通常调用 abort 或 exit。

    C++ 并不支持 class 专属之 new handlers，但可以自己实现。只需令每个一个class 提供自己的 set_new_handler 和 operator new 即可。

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

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

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

    九、杂项讨论

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

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

    条款55、让自己熟悉 Boost

  • 相关阅读:
    LC142.环形链表II
    react18【系列实用教程】useReducer —— 升级版的 useState （2024最新版）
    何为消息队列？它的特点是什么？
    Packet Tracer - 在 OSPFv2 中传播默认路由
    HTTP+ 加密 + 认证 + 完整性保护 =HTTPS（HTTPS 安全通信机制）
    C++设计模式-创建型设计模式：抽象工厂
    【C++/嵌入式笔试面试八股】二、14.内存管理基础 | 覆盖与交换 | 连续&非连续分配管理
    【数据结构与算法】LinkedList与链表
    沉思篇-剖析Jetpack的ViewModel
    优化jenkins on kubernetes构建性能慢问题
  • 原文地址：https://blog.csdn.net/weixin_45824067/article/details/133069961