C++11

介绍

统一的列表初始化 {}

所以 int a = {1}; 这一类就不推荐使用了.

initializer_list

新的声明

auto

decltype

nullptr

范围for

智能指针

STL 新容器

[C++-STL] 哈希表以及unordered_set和unordered_set的介绍

[C++-STL] 用哈希表封装unordered_map和unordered_set

右值引用 **

1. int &g = 10; 无法编译通过

   int &g = 10

2. const int &g = 10; 可以编译通过

   const int &g = 10

关于 左值引用的小总结:

1. 普通左值引用只能引用左值, 不能引用右值
2. 但是 const左值引用既可引用左值, 也可引用右值

关于 右值引用的小总结

1. 右值引用只能右值, 不能引用左值
2. 但是右值引用可以引用 move 以后的左值 (后面在解释)

右值是不能取地址的.

但是, 当我们对右值取别名之后, 就会使右值数据被存储到某个特定的位置. 所以可以对其取地址和赋值.

但这个特性没有什么应用场景.

对于区分左值或者右值, 可以根据这一句话和具体情况进行判断:

• 可以取地址的, 有名字的, 非临时的就是 左值;
• 不能取地址的, 没有名字的, 临时的就是 右值;

做返回值节省资源的例子:

string 的 += 重载实现时, 要实现连续 += 就要将 += 过的string作为返回值返回.

如果直接传值返回, 还是会造成深拷贝.

所以, 可以使用左值引用返回

1. 新的临时对象返回方式

   这里的新的返回方式并 不是指编写方式发生了改变, 即 返回值类型不做变化的, 依旧是 传值返回. 而是指, C++11之后 当一个函数返回的数据是一个临时对象 或 直接返回一个右值时(出了函数就要销毁的数据做返回值), 编译器会将返回值类型 识别为右值引用类型.

2. 两个新的 类的默认成员函数

   1. 默认移动构造函数

      什么是移动构造函数?

      还是以 July::string 为例, 移动拷贝构造的函数名是这样的:

      string(string &&str) 
      	: _str(nullptr)
      	, _size(0)
      	, _capacity(0) {
          ...
      }

      并且, 移动拷贝构造函数的实现方法, 通常是 直接将传入的参数拥有的数据 与 对象的成员数据进行交换.

      那么, July::string 之中, 实现应该是这样的:

      void swap(string& str) {
          std::swap(_str, str._str);
          std::swap(_size, str._size);
          std::swap(_capacity, str._capacity);
      }
      
      string(string &&str) 
      	: _str(nullptr)
      	, _size(0)
      	, _capacity(0) {
          swap(str);
      }

      这样传入右值引用参数, 并直接交换 传参数据 和 对象成员数据 来实例化对象的函数 就叫 移动构造函数

   2. 默认移动赋值重载函数

      根据移动构造函数的实现, 可以很快的推断出 移动赋值重载函数的实现:

      void swap(string& str) {
          std::swap(_str, str._str);
          std::swap(_size, str._size);
          std::swap(_capacity, str._capacity);
      }
      
      string& operator=(string &&str) {
          swap(str);
          
          return *this;
      }

      这样传入右值引用参数, 并直接交换 传参数据 和 对象成员数据 来给对象赋值的函数 就叫 移动赋值重载函数

之前已经介绍过, 针对类的各种构造函数 一些编译器对其进行一些优化

相关文章:

之前介绍的都是 拷贝构造 的 一些优化.

而C++11引入了 右值引用, 引入了 移动构造 之后. 编译其又会做什么优化呢?

以 to_string() 为例:

July::string to_string(int value) {
    bool flag = true;
    if (value < 0) {
        flag = false;
        value = 0 - value;
    }

    bit::string str;
    while (value > 0) {
        int x = value % 10;
        value /= 10;

        str += ('0' + x);
    }

    if (flag == false) {
        str += '-';
    }
    std::reverse(str.begin(), str.end());
    
    return str;
}

在C++11之前, 当我们使用 to_string() 的返回值 去实例化 July::string 对象时.

如果编译器不优化:

1. 传值返回, 需要生成临时对象, 会发生一次拷贝构造
2. 使用 July:string 对象 实例化 July::string 又会发生一次拷贝构造

而由于 生成临时对象这一步, 非常的多余且消耗资源. 函数传值返回, 已经是临时对象了, 还要再拷贝构造一个临时对象, 太多余了

所以 编译器会优化掉第一次的拷贝构造, 直接使用函数内 return时的临时对象 返回值 去拷贝构造实例化 July::string对象

而在C++11之后, 编译器会将传值返回 识别为传右值引用返回, 所以回去调用移动构造函数.

如果编译器不优化:

1. 传值返回, 需要生成临时对象, 但编译器会识别出右值引用返回, 所以 发生一次移动构造
2. 使用 一个右值 July:string 对象 实例化 July::string 又会发生一次 移动构造

还是有一步多余的临时对象的移动构造, 所以编译器会优化掉.

编译器会 直接使用函数内 return时的临时对象 返回值 去移动构造实例化 July::string 对象

什么是移动语义?

支持移动语义可以理解为, 可以通过那两个类的成员函数: 移动构造 和 移动赋值重载, 实例化新对象 或 给其他对象赋值.

容器中 另外的右值引用

万能引用与完美转发 **

什么是 引用折叠 :

当一个函数的形参为引用类型时, 一下这些情况会发生引用折叠:

1. 假如存在函数 Fun(int& f), 且存在 变量 int &a = b

   当 a 传入 Fun(), f 的类型可以看作 int& &

   此时, 会发生引用折叠 f 会折叠为 &左值引用

   折叠规则: T& & —> T&

2. 假如存在函数 Fun(int& f), 且存在 变量 int &&a = 10

   当 a 传入 Fun(), f 的类型可以看作 int& &&

   此时, 会发生引用折叠 f 会折叠为 &左值引用

   折叠规则: T& && —> T&

3. 假如存在函数 Fun(int&& f), 且存在 变量 int &a = b

   当 a 传入 Fun(), f 的类型可以看作 int&& &

   此时, 会发生引用折叠 f 会折叠为 &左值引用

   折叠规则: T&& & —> T&

4. 假如存在函数 Fun(int&& f), 且存在 变量 int &&a = 10

   当 a 传入 Fun(), f 的类型可以看作 int&& &&

   此时, 会发生引用折叠 f 会折叠为 &&右值引用

   折叠规则: T&& && —> T&&

总结就是, 只有出现 T&& && 引用折叠才会折叠为 &&右值引用.

1. 引用折叠了, 虽然 T&& && 折叠之后依旧 表示右值引用
2. Fun(t) 调用时, t 直接用作表达式(直接当变量使用), 会被认为是左值

std:move() 和 std::forward() 都是转换变量用的.

不过 move() 是将左值转换为右值引用

forward() 则是将 变量原本表示的类型还给它.

新的类功能

新默认成员函数

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载函数
6. const 取地址重载函数

1. 移动构造函数
2. 移动赋值重载函数

1. 如果没有自己实现 移动构造函数, 且 没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个. 那么编译器会自动生成一个默认移动构造.

   默认生成的移动构造函数, 对于内置类型成员会执行逐成员按字节拷贝(深拷贝). 对于自定义类型成员, 则需要看这个成员是否实现移动构造, 如果实现了就调用移动构造, 没有实现就调用拷贝构造.

2. 如果没有自己实现 移动赋值重载函数，且 没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个. 那么编译器会自动生成一个默认移动赋值.

   默认生成的移动构造函数, 对于内置类型成员会执行逐成员按字节拷贝. 对于自定义类型成员, 则需要看这个成员是否实现移动赋值, 如果实现了就调用移动赋值, 没有实现就调用拷贝赋值.

3. 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个 的意思是, 三个函数都没有实现

强制生成默认函数的关键字 default

禁止生成默认函数的关键字 delete

可变参数模板

1. 递归 展开参数包

   // 递归终止函数
   template <class T>
   void ShowList(const T& t) {
       cout << typeid(t).name() << ":";
       cout << t << endl;
   }
   
   // 展开函数
   template <class T, class ...Args>
   void ShowList(T value, Args... args) {
       cout << typeid(value).name() << ":";
       cout << value <<"    ";
       ShowList(args...);
   }
   
   int main() {
       ShowList(1);
       ShowList(1, 'A');
       ShowList(1, 'A', std::string("sort"));
   
       return 0;
   }

   我们可以通过在模板可变参数之前, 添加一个普通模板参数. 那么 传入模板的 第一个参数 就是 可直接使用 的.

   我们只需要在此函数内, 递归调用此函数. 那么 就可以不断 获得参数包内的第一个参数.

   直到递归到最后, 参数包内只剩一个参数时, 开始返回.

   这里递归结束的函数是 针对ShowList()实现了一个只有一个参数时的特化

   这段代码执行结果是:

2. 列表初始化 展开参数包

   template <class T>
   void PrintArg(T t) {
       cout << typeid(t).name() << ":";
       cout << t << "    ";
   }
   
   //展开函数
   template <class ...Args>
   void ShowList(Args... args) {
       int arr[] = { (PrintArg(args), 0)... };
       cout << endl;
   }
   
   int main() {
       ShowList(1);
       ShowList(1, 'A');
       ShowList(1, 'A', std::string("sort"));
       
       return 0;
   }

   在这种方法中, 我们使用逗号表达式保证 (PrintArg(args), 0) 的值为 0.

   然后还使用了列表初始化 来初始化一个变长数组.

   int arr[] = { (PrintArg(args), 0)... }

   会被展开为

   int arr[] = { (PrintArg(arg1), 0), (PrintArg(arg2), 0), (PrintArg(arg3), 0)... }

   当然, 这里的逗号表达式不是必须的, 只需要将 PrintArgs() 设置一个整型返回值, 就可以不用逗号表达式.

   template <class T>
   int PrintArg(T t) {
       cout << typeid(t).name() << ":";
       cout << t << "    ";
       
       return 0;
   }
   
   //展开函数
   template <class ...Args>
   void ShowList(Args... args) {
       int arr[] = { PrintArg(args)... };
       cout << endl;
   }

   这种方法的执行结果为:

emplace_back()

1. arr.emplace_back(11, "十一"); 和 arr.emplace_back(20, "二十");

   emplace_back() 会根据传入的两个参数, 直接调用 pair 的构造函数 构造一个 pair, 然后存储在 arr 末尾

2. arr.emplace_back(make_pair(30, "三十"));

   先执行 make_pair() 创建了一个临时的 pair 对象. 然后通过 emplace_back 在 arr 末尾创建了这个对象的副本. 它调用了两次 pair 构造函数: 一次在 make_pair, 一次在 emplace_back.

3. arr.push_back(make_pair(40, "四十"));

   先执行 make_pair() 创建了一个临时的 pair 对象. 然后通过 push_back 将创建这个对象的副本, 并将这个对象的副本插入到 arr 的末尾. 它也调用了两次 pair 构造函数：一次在 make_pair, 一次在 push_back

4. arr.push_back({ 50, "五十" });

   首先通过 列表初始化 创建了一个临时的 pair 对象. 然后通过 push_back 将创建这个对象的副本, 并将这个对象的副本插入到 arr 的末尾. 它也调用了两次 pair 构造函数：一次在 列表初始化, 一次在 push_back