《深入理解C++11》阅读笔记

电玩女神 2022-08-30 04:09 12阅读 0赞

## 1、新标准的诞生 ##

**C++11** 是 C++ 的第二个**主要**版本（前一个是 C++98 而后一个是 [C++17][C_17] ），并且是从 C++98 起的最重要更新。它引入了大量更改，标准化了既有实践，并改进了对 C++ 程序员可用的抽象。

在它最终由 ISO 在 2011 年 8 月 12 日承认前，人们曾使用名称 ‘C++0x’ ，因为它曾被期待在 2010 年之前发布。 C++03 与 C++11 期间花了 8 年时间，故而这是迄今为止最长的版本间隔。从那时起， C++ 规则地每 3 年更新一次。

C++11相对于C++98/03有哪些显著的增强呢？事实上，这包括一下几点：

*  通过内存模型、线程、原子操作等来支持本地并行编程（Native Concurrency）；
 *  通过统一初始化表达式、auto、decltype、移动语义等来统一对泛型编程的支持；
 *  通过constexpr、POD（概念）等更好地支持系统编程；
 *  通过内联命名空间、继承构造函数和右值引用等，以更好地支持库的构建。

**C++11主要的新语言特性：**

![6ff1058ebbdb54188291f76c7adf42e3.png][]

![acd3289477d26d690984fb2b7c3b2d1d.png][]

## 2、保持稳定性和兼容性 ##

### 2.1 保持与C99兼容 ###

#### 2.1.1 预定义宏 ####

![770f3cb49bdab76b4b2ec0dfbd79161d.png][]

#### 2.1.2 \_\_func\_\_预定义标识符 ####

在C++11中，允许其使用在类或结构体中。

#### 2.1.3 \_Pragma操作符 ####

#pragma once
    _Pragma("once") // 等价

#### 2.1.4 变长参数的宏定义以及\_\_VA\_ARGS\_\_ ####

#### 2.1.5 宽窄字符串的连接 ####

### 2.2 long long整型 ###

/** * @file 2.2.cpp * @brief * @author YongDu * @date 2021-07-17 */
    
    #include <climits>
    #include <iostream>
    
    int main() { 
      long long ll_min = LLONG_MIN;
      long long ll_max = LLONG_MAX;
      unsigned long long ull_max = ULLONG_MAX;
    
      std::cout << "min of long long: " << ll_min << std::endl;
      std::cout << "max of long long: " << ll_max << std::endl;
      std::cout << "max of unsigned long long: " << ull_max << std::endl;
    
      return 0;
    }
    
    // min of long long: -9223372036854775808
    // max of long long: 9223372036854775807
    // max of unsigned long long: 18446744073709551615

### 2.3 扩展的整型 ###

C/C++是一种弱类型语言，当运算、传参等类型不匹配的时候，整型间会发生隐式转换，即整型提升。

### 2.4 宏\_\_cplusplus ###

std::cout << __cplusplus << std::endl;

### 2.5 静态断言 ###

断言assert宏只有在程序运行时才能起作用，而\#error只在编译器预处理时才能起作用。

static\_assert是编译时期的断言，其使用范围不像assert受限制，在通常情况下，static\_assert可以用于任何名字空间。必须注意的是，static\_assert的断言表达式必须是编译时期可以计算的表达式，即必须是常量表达式。如果使用变量，则会导致错误。

### 2.6 noexcept修饰符和noexcept操作符 ###

断言适用于排除逻辑上不可能存在的状态，异常通常用于逻辑上可能发生的错误。

C++11标准中让类的析构函数默认是noexcept(true)的。

### 2.7 快速初始化成员变量 ###

### 2.8 非静态成员的sizeof ###

在C++11中，对非静态成员变量使用sizeof操作是合法的，而在C++98中，只有静态成员，或者对象的实例才能对其成员进行sizeof操作。

### 2.9 扩展的friend语法 ###

在C++11中，声明一个类为另外一个类的友元时，不再需要使用class关键字。因此可以为类模板声明友元类了。

class Poly;
    typedef Poly P;
    
    class LiLei { 
      friend class Poly; // C++98通过，C++11通过
    };
    class Jim { 
      friend Poly; // C++98失败，C++11通过
    };
    class HanMeiMei { 
      friend P; // C++98失败，C++11通过
    };
    
    class P;
    template <typename T>
    class People { 
      friend T;
    };
    
    People<P> PP;   // P为People的友元
    People<int> Pi; // 对于int类型模板参数，有元声明被忽略

### 2.10 final/override控制 ###

final关键字：使派生类不可覆盖它所修饰的虚函数

struct Object { 
      virtual void fun() = 0;
    };
    
    struct Base : public Object { 
      void fun() final;
    };
    
    struct Derive : public Base { 
      void fun(); // 无法通过编译
    };

![image-20210718005505333][]

虚函数描述符override：如果派生类在虚函数声明时使用了override描述符，那么该函数必须重载其基类中的同名函数，否则代码无法通过编译。

### 2.11 模板函数的默认模板参数 ###

类模板的默认参数必须从右至左的规则进行指定，函数模板的默认参数指定没有限制。

### 2.12 外部模板 ###

// test.h
    template <typename T>
    void fun(T) { }

// test1.cpp
    #include "test.h"
    
    template void fun<int>(int); // 显式地实例化
    
    void test1() {  fun(2); }

// test2.cpp
    #include "test.h"
    extern template void fun<int>(int); // 外部模板的声明
    
    void test1() { 
      fun(3);
      return;
    }

![cf83711f51ad5871985a410ded893ebe.png][]

如果外部模板声明出现与某个编译单元中，那么与之对应的显式实例化必须出现于另一个编译单元中或者同一个编译单元的后续代码中；外部模板声明不能用于一个静态函数（即文件域函数），但可以用于类静态成员函数（因为静态成员函数没有外部链接性，不可能在本编译单元之外出现）。

### 2.13 局部和匿名类型做模板实参 ###

匿名类型的声明不能在模板实参位置。

## 3、通用为本，专用为末 ##

### 3.1 继承构造函数 ###

如果派生类要使用基类的成员函数的话，可以通过using声明来完成。

struct A { 
      A(int i) { }
      A(double d, int i) { }
      A(float f, int i, const char *c) { }
      // ...
    };
    
    struct B : A { 
      using A::A; // 继承构造函数
      // ...
      virtual void ExtraInterface() { }
    };

C++11标准继承构造函数被设计为跟派生类中的各种默认函数（默认构造、析构、拷贝构造等）一样，是隐式声明的。这一位置如果一个继承构造函数不被相关代码使用，编译器不会为其产生真正的函数代码。

有的时候，基类构造函数的参数会有默认值。对于继承构造函数来讲，参数的默认值是不会被继承的。

如果基类的构造函数被声明为私有成员函数，或者派生类是从基类中虚继承的，那么就不能够在派生类中声明继承构造函数。此外，如果一旦使用了继承构造函数，编译器就不会再为派生类生成默认构造函数了。

### 3.2 委派构造函数 ###

C++11中的委派构造函数是在构造函数的初始化列表位置进行构造、委派的。

class Info { 
    public:
      Info() : Info(1, 'a') { }
      Info(int i) : Info(i, 'a') { }
      Info(char e) : Info(1, e) { }
    
    private:
      Info(int i, char e) : type(i), name(e) {  /*其它初始化*/
      }
      int type;
      char name;
      // ...
    };

### 3.3 右值引用：移动语义和完美转发 ###

在C++11中，右值是由两个概念构成的，一个是将亡值（xvalue，eXpiring Value），另一个则是纯右值（prvalue，Pure Rvalue）。其中纯右值就是C++98标准中右值的概念，讲的是用于辨识临时变量和一些不跟对象关联的值。比如非引用返回的函数返回的临时变量值就是一个纯右值。一些运算表达式，比如1 + 3产生的临时变量值，也是纯右值。而不跟对象关联的字面量值，比如：2、‘c’、true，也是纯右值。此外，类型转换函数的返回值、lambda表达式等，也都是右值。而将亡值则是C++11新增的跟右值引用相关的表达式，这样表达式通常是将要被移动的对象（移为他用），比如返回右值引用T&&的函数返回值、std::move的返回值，或者转换为T&&的类型转换函数的返回值。而剩余的，可以标识函数、对象的值都属于左值。在C++11的程序中，所有的值必属于左值、将亡值、纯右值三者之一。

常量左值引用在C++98标准中开始就是个“万能”的引用类型。它可以接受非常量左值、常量左值、右值对其进行初始化。而且在使用右值对其初始化的时候，常量左值引用还可以像右值引用一样将右值的生命期延长。不过相比于右值引用所引用的右值，常量左值所引用的右值在它的“余生”中只能是只读的。相对地，非常量左值只能接受非常量左值对其进行初始化。

![1ad42901b8d56dd1fd1cd58516d413e5.png][]

**std::move()：强制转化为右值**

std::move()并不能移动任何东西，唯一的功能就是将一个左值转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move()基本等同于一个类型转换。

**完美转发**

所谓完美转发，是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中的调用的另外一个函数。

**引用折叠**

![bef192d2b426abd7f526015703048d9a.png][]

#include <iostream>
    
    void runCode(int &&m) {  std::cout << "rvalue ref" << std::endl; }
    void runCode(int &m) {  std::cout << "lvalue ref" << std::endl; }
    void runCode(const int &&m) {  std::cout << "const rvalue ref" << std::endl; }
    void runCode(const int &m) {  std::cout << "const lvalue ref" << std::endl; }
    
    template <typename T>
    void perfectForward(T &&t) { 
      runCode(std::forward<T>(t));
    }
    
    int main() { 
      int a;
      int b;
      const int c = 1;
      const int d = 0;
      perfectForward(a);
      perfectForward(std::move(a));
      perfectForward(c);
      perfectForward(std::move(d));
      return 0;
    }
    
    // lvalue ref
    // rvalue ref
    // const lvalue ref
    // const rvalue ref

### 3.4 显式转换操作符 ###

显式转换并没有完全禁止从原类型到目标类型的转换，不过由于此时拷贝构造和非显式类型转换不被允许，通常不能通过赋值表达式或者函数参数的方式来产生这样一个目标类型。

### 3.5 列表初始化 ###

#include <string>
    #include <vector>
    
    using namespace std;
    
    enum Gender {  boy, girl };
    
    class People { 
    public:
      People(initializer_list<pair<string, Gender>> l) {  // initializer_list的构造函数
        auto i = l.begin();
        for (; i != l.end(); ++i) { 
          data.push_back(*i);
        }
      }
    
    private:
      vector<pair<string, Gender>> data;
    };
    
    int main() { 
      People ship2021 = { { "Garifield", boy}, { "HelloKitty", girl}};
      return 0;
    }

在C++11中，使用初始化列表进行初始化的数据编译器是会检查其是否发生类型收窄的。

### 3.6 POD类型 ###

[C++中的POD类型C++中的POD类型][C_POD_C_POD]

### 3.7 非受限联合体 ###

C++11，任何非引用类型都可以成为联合体的数据成员，这样的联合体即所谓的非受限联合体。

### 3.8 用户自定义字面量 ###

/** * @file 3.8.cpp * @brief * @author YongDu * @date 2021-07-18 */
    #include <iostream>
    using namespace std;
    
    struct RGBA { 
      uint8_t r;
      uint8_t g;
      uint8_t b;
      uint8_t a;
      RGBA(uint8_t R, uint8_t G, uint8_t B, uint8_t A = 0) : r(R), g(G), b(B), a(A) { }
    };
    
    RGBA operator""_C(const char *col, size_t n) { 
      const char *p = col;
      const char *end = col + n;
      const char *r, *g, *b, *a;
      r = g = b = a = nullptr;
      for (; p != end; ++p) { 
        if ('r' == *p)
          r = p;
        else if ('g' == *p)
          g = p;
        else if ('b' == *p)
          b = p;
        else if ('a' == *p)
          a = p;
      }
      if ((nullptr == r) || nullptr == g || nullptr == b)
        throw;
      else if (nullptr == a)
        return RGBA(atoi(r + 1), atoi(g + 1), atoi(b + 1));
      else
        return RGBA(atoi(r + 1), atoi(g + 1), atoi(b + 1), atoi(a + 1));
    }
    
    std::ostream &operator<<(std::ostream &out, RGBA &col) { 
      return out << "r: " << (int)col.r << ", g: " << (int)col.g << ", b: " << (int)col.b << ", a: " << (int)col.a << endl;
    }
    
    void blend(RGBA &&col1, RGBA &&col2) {  cout << "blend" << endl << col1 << col2 << endl; }
    
    int main() { 
      blend("r255 g240 b155"_C, "r15 g255 b10 a7"_C);
      return 0;
    }
    
    // blend
    // r: 255, g: 240, b: 155, a: 0
    // r: 15, g: 255, b: 10, a: 7

### 3.9 内联名字空间 ###

通过关键字“inline namespace”就可以声明一个内联的名字空间，内联的名字空间允许程序员在父名字空间中定义或特化子名字空间的模板。

参数关联名字查找：即ADL，这个特性允许编译器在名字空间内找不到函数名时，在参数的名字空间内查找函数名字。

### 3.10 模板的别名 ###

### 3.11 一般化的SFINEA规则 ###

## 4、新手易学，老兵易用 ##

### 4.1 右尖括号>的改进 ###

### 4.2 auto类型推导 ###

**4种不能推导的情况：**

*  auto不能是其形参类型
 *  对于结构体来说，非静态成员变量的类型不能是auto的。
 *  声明auto数组。
 *  在实例化模板的时候使用auto作为模板参数

### 4.3 decltype ###

### 4.4 追踪返回类型 ###

template <typename T1, typename T2>
    auto Sum = (T1 & t1, T2 &t2) -> decltype(t1 + t2) { 
      return t1 + t2;
    }

### 4.5 基于范围的for循环 ###

## 5、提高类型安全 ##

### 5.1 强类型枚举 ###

enum class Type { General, Light, Medium, Heavy};

强枚举类型有以下几点优势：

*  强作用域，强类型枚举成员的名称不会输出到其父作用域空间；
 *  转换限制，强类型枚举成员的值不可以与整型隐式相互转换；
 *  可以指定底层类型。

enum class Type : char {  General, Light, Medium, Heavy };

### 5.2 堆内存管理：智能指针与垃圾回收 ###

## 6、提高性能及操作硬件的能力 ##

### 6.1 常量表达式 ###

const：运行时常量

constexpr：编译时常量

**常量表达式函数：**

*  函数体只有单一的return返回语句
 *  函数必须具有返回值（不能是void函数）
 *  在使用前必须已有定义
 *  return返回语句表达式中不能使用非常量表达式的函数、全局数据，且必须是一个常量表达式

### 6.2 变长模板 ###

### 6.3 原子类型与原子操作 ###

在C++11中，原子类型只能从其模板参数类型中进行构造，标准不允许原子类型进行拷贝构造、移动构造以及使用operator=等，以防止发生意外。

### 6.4 线程局部存储 ###

### 6.5 快速退出：quick\_exit和at\_quick\_exit ###

#include <iostream>
    using namespace std;
    
    struct A { 
      ~A() {  cout << "Destruct A." << endl; }
    };
    
    void closeDevice() {  cout << "device is closed." << endl; }
    
    int main() { 
      A a;
      at_quick_exit(closeDevice);
      quick_exit(0);
      return 0;
    }
    
    // device is closed.

## 7、为改变思考方式而改变 ##

### 7.1 指针空值 – nullptr ###

### 7.2 默认函数的控制 ###

“=default”

“=delete”

### 7.3 lambda函数 ###

[capture](parameters) mutable -> return-type{ statement}

*  \[capture\]：捕捉列表。捕捉列表总是出现在lambda函数的开始处。事实上，\[\]是lambda引出符。编译器根据该引出符判断接下来的代码是否是lambda函数。捕捉列表能够捕捉上下文中的变量以供lambda函数使用。
 *  (parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号()一起省略
 *  mutable：mutable修饰符。默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
 *  \->return-type：返回类型。用追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值的时候也可以连同符号->一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
 *  \{statement\}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

## 8、融入实际应用 ##

### 8.1 对齐支持 ###

### 8.2 通用属性 ###

[[noreturn]]
    [[carries_dependency]]

### 8.3 Unicode支持 ###

### 8.4 原生字符串字面量 ###

#include <iostream>
    using namespace std;
    
    int main() { 
      cout << R"(hello, \n world)"
           << endl;
      return 0;
    }
    
    // hello, \n
    // world

[C_17]: https://zh.cppreference.com/w/cpp/17
[6ff1058ebbdb54188291f76c7adf42e3.png]: /images/20220829/8208de5a195b4a5bb7ca224b22a435bb.png
[acd3289477d26d690984fb2b7c3b2d1d.png]: /images/20220829/145ed051ccce406f81364b16647bda6b.png
[770f3cb49bdab76b4b2ec0dfbd79161d.png]: /images/20220829/4a93d8a2904a41d4ac0b1785daae708a.png
[image-20210718005505333]: /images/20220829/61f39e51d71546488223a98c6483a98d.png
[cf83711f51ad5871985a410ded893ebe.png]: /images/20220829/509f3a8f77304fa9aacce756bf67bccd.png
[1ad42901b8d56dd1fd1cd58516d413e5.png]: /images/20220829/eaf9663896ec4af39abe307bf3634f69.png
[bef192d2b426abd7f526015703048d9a.png]: /images/20220829/49e59aa678374596a75cacd73f2f1d40.png
[C_POD_C_POD]: https://blog.csdn.net/weixin_42482896/article/details/118271161