C++11

目录

1.C++11简介

2. 统一的列表初始化

3. 声明

4 范围for循环

5 智能指针

auto_ptr（已废弃）

unique_ptr

shared_ptr

weak_ptr

对比

6 STL中一些变化

7 右值引用和移动语义

8 新的类功能

9 可变参数模板

10 lambda表达式

11 包装器

12.bind函数

---

1.C++11简介

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了

C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞

进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。

从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。 相比于

C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中

约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，

C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更

强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个

重点去学习。

本文分为以下小结去进行学习

1.C++11 简介

2. 列表初始化

3. 变量类型推导

4. 范围 for 循环

5. final 与 override

6. 智能指针

7. 新增加容器 --- 静态数组 array 、 forward_list 以及 unordered 系列

8. 默认成员函数控制

9. 右值引用

10. lambda 表达式

小故事：

1998年是C++标准委员会成立的第一年，本来计划以后每5年视实际需要更新一次标准，C++国际

标准委员会在研究C++ 03的下一个版本的时候，一开始计划是2007年发布，所以最初这个标准叫

C++ 07。但是到06年的时候，官方觉得2007年肯定完不成C++ 07，而且官方觉得2008年可能也

完不成。最后干脆叫C++ 0x。x的意思是不知道到底能在07还是08还是09年完成。结果2010年的

时候也没完成，最后在2011年终于完成了C++标准。所以最终定名为C++11。

2. 统一的列表初始化

2.1 ｛｝初始化

在 C++98 中，标准允许使用花括号 {} 对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{
 int _x;
 int _y;
};
int main()
{
 int array1[] = { 1, 2, 3, 4, 5 };
 int array2[5] = { 0 };
 Point p = { 1, 2 };
 return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于 所有的内置类型和用户自

定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

struct Point
{
 int _x;
 int _y;
};
int main()
{
 int x1 = 1;
 int x2{ 2 };
 int array1[]{ 1, 2, 3, 4, 5 };
 int array2[5]{ 0 };
 Point p{ 1, 2 };
 // C++11中列表初始化也可以适用于new表达式中
 int* pa = new int[4]{ 0 };
 return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化

class Date
{
public:
 Date(int year, int month, int day)
 :_year(year)
 ,_month(month)
 ,_day(day)
 {
 cout << "Date(int year, int month, int day)" << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1(2022, 1, 1); // old style
 // C++11支持的列表初始化，这里会调用构造函数初始化
 Date d2{ 2022, 1, 2 };
 Date d3 = { 2022, 1, 3 };
 return 0;
}

2.2 std::initializer_list

上述{}构造可以成功，原因是，{}被识别成了一个个的initializer_list对象。这是C++11引入的一个对象，包含在<initializer_list>中

int main()
{
 // the type of il is an initializer_list 
 auto il = { 10, 20, 30 };
 cout << typeid(il).name() << endl;
 return 0;
}

std::initializer_list使用场景：

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加

std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=

的参数，这样就可以用大括号赋值

让容器具有initializer_list的构造方式

在外面传{}时，initializer_list对象可以接收这个参数，开辟好对应的空间，采用范围for遍历it，执行push_back()函数。

下面是对initializer_list，以及initializer_list如何去构造其他容器的详细介绍。

initializer_list 是 C++11 中引入的一个标准库类型，它提供了一个轻量级的对象，用于表示一组具有相同类型的值的集合。这个类型特别适用于初始化，因为它可以用来构造和初始化标准库容器（如 vector、map、set 等）以及自定义类型的对象。

initializer_list 的特点：

初始化列表：initializer_list 可以直接使用花括号 {} 初始化。

只读：initializer_list 中的元素是只读的，不能被修改。

类型相同：列表中的所有元素必须是同一种类型，或者可以隐式转换为同一类型。

大小已知：可以通过 size() 成员函数获取列表中元素的数量。

如何使用 initializer_list 构造其他容器：

下面是一些示例，展示如何使用 initializer_list 来构造不同的标准库容器。

1. 构造 vector：

#include <vector>

#include <initializer_list>



std::vector<int> v = {1, 2, 3, 4, 5};

这里，{1, 2, 3, 4, 5} 是一个 initializer_list<int>，它被用来初始化 vector<int>。

2. 构造 map：

#include <map>

#include <initializer_list>



std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};

这里，initializer_list 包含了多个 std::pair 对象，每个 pair 对象由两个值组成，分别对应 map 的键和值。

3. 构造 set：

#include <set>

#include <initializer_list>



std::set<int> s = {4, 1, 3, 2};

initializer_list 用于初始化 set，注意 set 中的元素将会根据其值自动排序。

4. 自定义类型：

如果你的自定义类型有一个接受 initializer_list 的构造函数，你也可以用同样的方式来初始化它：

#include <initializer_list>



class MyClass {

public:

    MyClass(std::initializer_list<int> list) {

        for (int value : list) {

            // 处理 list 中的每个元素

        }

    }

};



MyClass myClass = {1, 2, 3, 4, 5};

#include <iostream>
#include <initializer_list>

void printList(std::initializer_list<int> list) {
    for (int value : list) {
        std::cout << value << ' ';
    }
    std::cout << '\n';
}

int main() {
    printList({1, 2, 3, 4, 5}); // 输出：1 2 3 4 5
    return 0;
}

花括号初始化表达式 {1, 2, 3, 4, 5} 创建了一个临时的 initializer_list<int> 对象，它被传递给 printList 函数。函数内部通过迭代器遍历列表并打印每个元素。

内部机制相当简单，它通过一个指向元素数组的指针和表示元素数量的计数器来管理数据，而不直接存储元素。这使得 initializer_list 成为一种轻量级、只读的、易于使用的工具，用于初始化其他对象和容器。

STL再C++11之后，各种容器都支持initializer_list的初始化。

赋值重载operator=也有initializer_list的版本。

注意：

当使用 initializer_list 初始化容器时，如果容器已经包含元素，这些元素将被列表中的新元素替换。

initializer_list 可以作为函数参数，使得函数能够接受任意数量的同类型参数。

initializer_list 的引入大大简化了 C++ 中对容器和对象的初始化过程，使得代码更加简洁易读。

3. 声明

c++11 提供了多种简化声明的方式，尤其是在使用模板时。

3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局

部的变量默认就是自动存储类型，所以auto就没什么价值了。 C++11中废弃auto原来的用法，将

其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初

始化值的类型。

int main()
{
int i = 10;
auto p = &i;
auto pf = strcpy;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0;
}

3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。

typeid().name是用字符串的形式获取类型，decltype则是获取类型，这个类型可以用来定义变量。

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;
}
int main()
{
const int x = 1;
double y = 2.2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p;      // p的类型是int*
cout << typeid(ret).name() << endl;
cout << typeid(p).name() << endl;
F(1, 'a');
return 0;
}

decltype、typeid、dynamic_cast是RTTI的关键。

示例 1：推断变量类型

int x = 10;
decltype(x) y = x; // y的类型是int，与x相同

示例 2：推断表达式类型

int a = 5, b = 6;
decltype(a + b) c = a + b; // c的类型是int，因为a + b的结果是int

示例 3：与auto结合使用

auto x = 1; // x的类型是int
auto y = 2.0; // y的类型是double

decltype(x + y) z; // z的类型是double，因为x + y的结果是double

decltype(//表达式） 可以被编译器识别为特定的类型。

3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示

整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

4 范围for循环

C++11引入了范围for循环（也称为基于范围的for循环或for-each循环），它提供了一种更简洁的方式来遍历容器或数组中的元素。这种循环简化了迭代过程，特别是在不需要使用迭代器时。

以下是范围for循环的基本语法：

for (declaration : expression) {
    // 循环体
}

这里的declaration是一个变量声明，用于在每次迭代中保存expression中当前元素的副本。expression是一个序列，比如数组、容器或者其他任何支持begin和end成员函数或自由函数的对象。

下面是几个范围for循环的示例：

示例 1：遍历数组

int arr[] = {1, 2, 3, 4, 5};

for (int i : arr) {
    std::cout << i << " ";
}
// 输出: 1 2 3 4 5

在这个例子中，i在每次迭代中接收数组arr的下一个元素。

示例 2：遍历容器

#include <vector>
#include <iostream>

std::vector<int> vec = {1, 2, 3, 4, 5};

for (int num : vec) {
    std::cout << num << " ";
}
// 输出: 1 2 3 4 5

这里，num在每次迭代中接收vec容器的下一个元素。

示例 3：使用引用避免复制

for (int &num : vec) {
    num *= 2; // 直接修改容器中的元素
}

在这个例子中，我们使用引用来直接修改容器中的元素，而不是创建元素的副本。

示例 4：遍历字符串

#include <string>
#include <iostream>

std::string str = "Hello World";

for (char c : str) {
    std::cout << c << " ";
}
// 输出: H e l l o   W o r l d

范围for循环也可以用来遍历字符串中的每个字符。

注意事项：

• 范围for循环中的变量声明可以是值类型、引用类型或指针类型。
• 如果需要修改容器中的元素，应该使用引用。
• 范围for循环不支持直接跳过或添加元素，它只用于遍历。
• 如果需要使用迭代器的高级特性，比如跳跃或条件遍历，那么应该使用传统的for循环。

范围for循环大大简化了C++中的遍历操作，使得代码更加简洁和易于阅读。

5 智能指针

在C++中，智能指针是用于管理动态分配内存的对象，它们能够自动释放分配的内存，从而避免内存泄漏。以下是对auto_ptr、unique_ptr、shared_ptr和weak_ptr的简要介绍以及它们之间的对比。

auto_ptr（已废弃）

auto_ptr是C++98中引入的第一个智能指针，旨在通过对象生命周期管理来简化动态内存分配。然而，auto_ptr有一个很大的问题：它通过复制操作转移所有权，这意味着复制一个auto_ptr会将资源的所有权从源指针转移到目标指针，源指针变为空。

简介:

• auto_ptr在C++11中被废弃，并在C++17中被移除。
• 它使用<memory>头文件。
• 它通过复制操作转移资源所有权。

缺点:

• 不支持数组。
• 复制auto_ptr会导致原始指针悬空。

unique_ptr

unique_ptr是C++11中引入的智能指针，用于替代auto_ptr。它提供了严格的所有权语义，即同一时间只能有一个unique_ptr实例拥有资源。

简介:

• unique_ptr也使用<memory>头文件。
• 它拥有独占所有权语义。
• 支持自定义删除器。

特点:

• 不支持复制操作，但可以通过std::move转移所有权。
• 可以释放所有权，通过release()或reset()方法。

shared_ptr

shared_ptr也是C++11引入的，它允许多个指针共享同一资源。资源会在最后一个shared_ptr析构时释放。

简介:

• shared_ptr使用<memory>头文件。
• 它使用引用计数机制来管理资源。
• 支持复制和共享所有权。

特点:

• 资源在所有拥有它的shared_ptr都被销毁后释放。
• 可以通过use_count()方法查看引用计数。

weak_ptr

weak_ptr是与shared_ptr配合使用的智能指针，用于解决shared_ptr可能引起的循环引用问题。它不会增加引用计数，因此不会影响资源的生命周期。

简介:

• weak_ptr使用<memory>头文件。
• 它用于观察shared_ptr管理的资源，但不拥有资源。
• 可以用来防止循环引用。

特点:

• 必须通过shared_ptr来创建。
• 需要使用lock()方法来获取临时的shared_ptr。

对比

• 所有权:

  • auto_ptr和unique_ptr拥有独占所有权。
  • shared_ptr拥有共享所有权。
  • weak_ptr不拥有资源，只是观察。

• 复制操作:

  • auto_ptr在复制时转移所有权。
  • unique_ptr不支持复制，但可以转移所有权。
  • shared_ptr支持复制，增加引用计数。
  • weak_ptr可以复制，但不会影响引用计数。

• 性能:

  • unique_ptr通常比shared_ptr更轻量，因为它不需要引用计数。
  • shared_ptr和weak_ptr由于引用计数机制，会有额外的性能开销。

• 用途:

  • auto_ptr已不推荐使用。
  • unique_ptr适用于当对象只被一个指针所拥有时。
  • shared_ptr适用于当对象需要被多个指针共享时。
  • weak_ptr用于解决shared_ptr可能导致的循环引用问题。

综上所述，auto_ptr由于设计上的问题已被废弃，而unique_ptr、shared_ptr和weak_ptr则是现代C++编程中管理动态内存的常用工具。在选择使用哪种智能指针时，应根据具体的所有权需求和使用场景来决定。

6 STL中一些变化

新容器

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和 unordered_set。

容器中的一些新方法

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得

比较少的。

比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是

可以返回const迭代器的，这些都是属于锦上添花的操作。

7 右值引用和移动语义

7.1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们

之前学习的引用就叫做左值引用。 无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)， 我们可以获取它的地址+可以对它赋

值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左

值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}

什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如： 字面常量、表达式返回值，函数返回值(这个不能是左值引

用返回)(一些临时的、具有常性的值）等， 右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能

取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可

以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地

址，也可以修改rr1。如果不想rr1被修改，可以用 const int&& rr1 去引用，是不是感觉很神奇，

这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

左值可以出现在等号的左右两边，但是右值只能出现在等号的右边（等号指的是赋值符号）

int main()
{
 double x = 1.1, y = 2.2;
 int&& rr1 = 10;
 const double&& rr2 = x + y;
 rr1 = 20;
 rr2 = 5.5;  // 报错
 return 0;
}

7.2 左值引用与右值引用比较        

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。

2. 但是const左值引用既可引用左值，也可引用右值。(权限问题）

int main()
{
    // 左值引用只能引用左值，不能引用右值。
    int a = 10;
    int& ra1 = a;   // ra为a的别名
    //int& ra2 = 10;   // 编译失败，因为10是右值
    // const左值引用既可引用左值，也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    return 0;
}

右值引用总结：

1. 右值引用只能右值，不能引用左值。

2. 但是右值引用可以move以后的左值。

int main()
{
 // 右值引用只能右值，不能引用左值。
 int&& r1 = 10;
 
 // error C2440: “初始化”: 无法从“int”转换为“int &&”
 // message : 无法将左值绑定到右值引用
 int a = 10;
 int&& r2 = a;
 // 右值引用可以引用move以后的左值    
 int&& r3 = std::move(a);
 return 0;
}

右值可以进行分类：

7.3 右值引用使用场景和意义

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引 用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

左值引用（lvalue reference）和右值引用（rvalue reference）在C++中都有其用途，但是左值引用在某些情况下存在以下短板，使得右值引用显得尤为重要：

1. 无法直接引用临时对象(右值）：左值引用不能绑定到临时对象（右值）上，这意味着在不需要复制的情况下，无法直接使用左值引用来延长临时对象的生命周期。

2. 无法避免不必要的复制：在没有右值引用的情况下，函数参数传递时，即使是临时对象，也必须进行复制操作。这在处理大型对象或资源密集型对象（如包含大量数据的容器或动态分配内存的对象）时会导致性能问题。

3. 资源管理效率低下：左值引用无法利用移动语义，这意味着在资源转移时，必须进行完整的复制操作，而不是更高效的“移动”操作。这会降低资源管理的效率，尤其是在涉及动态内存分配时。

在上述代码中，存在连续的构造、拷贝构造，编译器会进行优化。

但是仍存在缺陷：        

每一次产生临时对象都会产生一个不必要的资源（深拷贝），这个临时对象管理的资源会经历创新、销毁的不必要操作。

假设我们不进行连续的拷贝，即创建与赋值分开进行。

每产生一个临时对象，都会产生一个不必要的资源（深拷贝每次都会开出一样的资源，造成资源浪费），那我们能不能减少不必要资源的产生呢？

临时对象窃取你的资源。所以左值引用与右值引用的真正价值，是在区分左右值对象，可以在处理将亡值时，减少不必要的资源浪费。

右值引用和移动语义解决上述问题：

在bit::string中增加移动构造， 移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不

用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

// 移动构造
string(string&& s)
 :_str(nullptr)
 ,_size(0)
 ,_capacity(0)
{
 cout << "string(string&& s) -- 移动语义" << endl;
 swap(s);
}
int main()
{
 bit::string ret2 = bit::to_string(-1234);
 return 0;
}

返回时产生一个临时对象，先在初始化列表进行临时对象的初始化，然后临时对象与参与拷贝的模板调换资源。模板对象（str）出了作用域析构。

临时对象完成赋值任务之后也析构。

因此在赋值中，也进行一次资源转移。

这样资源就最终转移到了返回值上

再运行上面bit::to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用

了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。

/*

函数名相同，参数类型不同构成重载，当参数类型的引用类型不同也构成重载吗？

是的，在C++中，当函数名相同但参数类型不同时，确实可以构成函数重载。这不仅适用于基本类型参数，也适用于引用类型参数。如果参数的引用类型不同，这也被认为是参数类型的不同，因此可以构成重载。

具体来说，以下几种情况可以构成重载：

参数的数量不同。

参数的类型不同。

参数的引用或cv-限定符（const/volatile）不同。

*/

不仅仅有移动构造，还有移动赋值：

在bit::string类中增加移动赋值函数，再去调用bit::to_string(1234)，不过这次是将

bit::to_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
int main()
{
 bit::string ret1;
 ret1 = bit::to_string(1234);
 return 0;
}
// 运行结果：
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义

这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象

接收，编译器就没办法优化了。bit::to_string函数中会先用str生成构造生成一个临时对象，但是

我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时

对象做为bit::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。

左值引用返回的原因：

ret1是一个已经建立好的左值对象，所以采用左值引用返回。

这样的话就会共享一个资源， 因此右值引用传参的价值就是窃取资源。

移动语义的核心就是，将原来对象的资源清空，本对象获取原来对象的资源。对于日期类这种不涉及资源管理的简单类，则是没必要实现移动构造与移动复制。移动构造与移动赋值的精华是窃取资源。

移动语义的意义：1.不怕传值返回，接收返回值2.C++11之后，只要实现了移动语义，那么深拷贝也可以直接使用库函数的swap。这里借助移动语义，可以完成资源的置换。

C指向a的资源（同时让a指向c的资源)，a指向b的资源，b指向c的资源。这里调用的都是右值的赋值和重载。

C++11之后，所有容器都增加了引用构造和引用赋值。

7.4 右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能

真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move

函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，

它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

move不会影响当前对象的属性，而是将函数的返回值转变属性。返回的临时对象都是将亡值。

int main()
{
 bit::string s1("hello world");
 // 这里s1是左值，调用的是拷贝构造
 bit::string s2(s1);
 // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
 // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
 // 资源被转移给了s3，s1被置空了。
 bit::string s3(std::move(s1));
 return 0;
}

s1变成右值之后，会调用移动语义。

STL 容器插入接口函数也增加了右值引用版本：

7.5 完美转发

模板中的&& 万能引用

// 模板中的 && 不代表右值引用，而是万能引用，其既能接收左值又能接收右值。

// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，

// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，

// 我们希望能够在传递过程中保持它的左值或者右值的属性 , 就需要用我们下面学习的完美转发

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
 Fun(t);
}
int main()
{
 PerfectForward(10);           // 右值
 int a;
 PerfectForward(a);            // 左值
 PerfectForward(std::move(a)); // 右值
 const int b = 8;
 PerfectForward(b);      // const 左值
 PerfectForward(std::move(b)); // const 右值
 return 0;
}

std::forward 完美转发在传参的过程中保留对象原生类型属性

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
 Fun(std::forward<T>(t));
}
int main()
{
 PerfectForward(10);           // 右值
 int a;
 PerfectForward(a);            // 左值
 PerfectForward(std::move(a)); // 右值
 const int b = 8;
 PerfectForward(b);      // const 左值
 PerfectForward(std::move(b)); // const 右值
 return 0;
}

万能引用接收之后，，在调用Func函数时，采用了forward<T>(t)来保证t原本的数据属性。

完美转发实际中的使用场景：

template<class T>
struct ListNode
{
 ListNode* _next = nullptr;
 ListNode* _prev = nullptr;
 T _data;
};
template<class T>
class List
{
 typedef ListNode<T> Node;
public:
 List()
 {
 _head = new Node;
 _head->_next = _head;
 _head->_prev = _head;
 }
 void PushBack(T&& x)
 {
 //Insert(_head, x);
 Insert(_head, std::forward<T>(x));
 }
 void PushFront(T&& x)
 {
 //Insert(_head->_next, x);
 Insert(_head->_next, std::forward<T>(x));
 }
 void Insert(Node* pos, T&& x)
 {
 Node* prev = pos->_prev;
 Node* newnode = new Node;
 newnode->_data = std::forward<T>(x); // 关键位置
 // prev newnode pos
 prev->_next = newnode;
 newnode->_prev = prev;
 newnode->_next = pos;
 pos->_prev = newnode;
 }
 void Insert(Node* pos, const T& x)
 {
 Node* prev = pos->_prev;
 Node* newnode = new Node;
 newnode->_data = x; // 关键位置
 // prev newnode pos
 prev->_next = newnode;
newnode->_prev = prev;
 newnode->_next = pos;
 pos->_prev = newnode;
 }
private:
 Node* _head;
};
int main()
{
 List<bit::string> lt;
 lt.PushBack("1111");
 lt.PushFront("2222");
 return 0;
}

在模板类的模板函数中，T&&  X是一个万能引用。forward<T>()可以保持参数的用万能引用接收后的属性。一般在万能引用之后，使用该值都需要完美转发。

这里的关键位置就是触发operator=的地方！（是否调用移动语义）

可见左值不能随便转化为右值！

8 新的类功能

默认成员函数

原来C++类中，有6个默认成员函数：

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。

C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任

意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类

型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，

如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中

的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内

置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋

值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造

完全类似)

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

// 以下代码在vs2013中不能体现，在vs2019下才能演示体现上面的特性。
class Person
{
public:
 Person(const char* name = "", int age = 0)
 :_name(name)
 , _age(age)
 {}
 /*Person(const Person& p)
:_name(p._name)
 ,_age(p._age)
 {}*/
 /*Person& operator=(const Person& p)
 {
 if(this != &p)
 {
 _name = p._name;
 _age = p._age;
 }
 return *this;
 }*/
 /*~Person()
 {}*/
private:
 bit::string _name;
 int _age;
};
int main()
{
 Person s1;
 Person s2 = s1;
 Person s3 = std::move(s1);
 Person s4;
 s4 = std::move(s2);
 return 0;
}

类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。如果初始化列表更新值，那么将不使用缺省值，否则将使用类内初始化的值。

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

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原

因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以

使用default关键字显示指定移动构造生成。

class Person
{
public:
 Person(const char* name = "", int age = 0)
 :_name(name)
 , _age(age)
 {}
 Person(const Person& p)
 :_name(p._name)
 ,_age(p._age)
 {}
Person(Person&& p) = default;
private:
 bit::string _name;
 int _age;
};
int main()
{
 Person s1;
 Person s2 = s1;
 Person s3 = std::move(s1);
 return 0;
}

强制编译器生成默认的拷贝构造。 使用方式：函数声明 = default；

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

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁

已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即

可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数 。

行为上像是函数被删除。

class Person
{
public:
 Person(const char* name = "", int age = 0)
 :_name(name)
 , _age(age)
 {}
 Person(const Person& p) = delete;
private:
 bit::string _name;
 int _age;
};
int main()
{
 Person s1;
 Person s2 = s1;
 Person s3 = std::move(s1);
 return 0;
}

继承和多态中的final与override关键字

final禁止虚函数重写、禁止继承。

override检查是否完成虚函数的重写。

9 可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比

C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改

进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现

阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大

家如果有需要，再可以深入学习。

下面就是一个基本可变参数的函数模板

// Args 是一个模板参数包， args 是一个函数形参参数包

// 声明一个参数包 Args...args ，这个参数包中可以包含 0 到任意个模板参数。

template < class ... Args >

void ShowList ( Args ... args )

{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数

包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，

只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特

点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变

参数，所以我们的用一些奇招来一一获取参数包的值。

递归函数方式展开参数包

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

这是通过参数的最有匹配原则去实现的，只有一个参数时，会优先匹配上面的模板函数，而不是下面的参数包。（函数名相同，参数不同）

逗号表达式展开参数包

这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg

不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式

实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行

printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列

表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0),

(printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...

(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)

打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在

数组构造的过程展开参数包

template <class T>
void PrintArg(T t)
{
 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;
}

STL容器中的empalce相关接口函数：

template < class ... Args >

void emplace_back ( Args && ... args )；

首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和

emplace系列接口的优势到底在哪里呢？

int main()
{
 std::list< std::pair<int, char> > mylist;
 // emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
 // 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
 mylist.emplace_back(10, 'a');
 mylist.emplace_back(20, 'b');
 mylist.emplace_back(make_pair(30, 'c'));
 mylist.push_back(make_pair(40, 'd'));
 mylist.push_back({ 50, 'e' });
 for (auto e : mylist)
 cout << e.first << ":" << e.second << endl;
 return 0;
}
int main()
{
// 下面我们试一下带有拷贝构造和移动构造的bit::string，再试试呢
// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
// 是先构造，再移动构造，其实也还好。
 std::list< std::pair<int, bit::string> > mylist;
 mylist.emplace_back(10, "sort");
 mylist.emplace_back(make_pair(20, "sort"));
 mylist.push_back(make_pair(30, "sort"));
 mylist.push_back({ 40, "sort"});
 return 0;
}

对于pair，它传参时可以自动将两个对象推导成pair，这是因为存在参数包。

通过右值构造和右值引用，借助完美准发，可以实现资源的直接转移，而不是临时对象额外的拷贝和析构这是emplace_back的优势！

emplace系列接口与insert接口相比，主要优势在于它们能够直接在容器内部构造元素，而不是先构造一个临时对象，然后再将其移动或复制到容器中。这样做有几个优点：

1. 避免不必要的拷贝或移动：

   • 当使用insert接口时，通常需要先创建一个对象，然后将这个对象插入到容器中。如果使用的是push_back或insert与一个对象，那么可能会发生一次拷贝构造或移动构造。
   • emplace系列接口允许直接在容器管理的内存空间中构造对象。这意味着，如果你传递的参数能够直接用于构造目标类型的对象，那么就可以避免创建临时对象，从而减少拷贝或移动操作。

2. 构造效率：

   • emplace接口通常能够直接使用提供的参数列表来调用目标类型的构造函数，这可能会比先构造一个临时对象再移动或复制到容器中更高效。

3. 语法简洁：

   • 使用emplace接口可以直接在容器内构造对象，而不需要显式创建一个临时对象。这使得代码更加简洁和直观。

下面是一个简单的比较：

使用insert:

std::vector<std::string> vec;
std::string temp("example");
vec.push_back(temp); // 可能发生一次移动构造

使用emplace_back:

std::vector<std::string> vec;
vec.emplace_back("example"); // 直接在容器内构造，无需临时对象

在第二个例子中，字符串"example"作为参数直接传递给emplace_back，容器会在其内部直接使用这个参数来构造一个std::string对象。

下面是emplace_back接口的一些具体优势：

• 完美转发：由于使用了万能引用（Args&&... args），emplace_back能够完美转发参数，这意味着参数的左值/右值属性被保留，可以更有效地利用移动语义。
• 直接构造：不需要先构造一个局部对象，然后再将这个对象复制或移动到容器中，减少了构造和析构的开销。
• 支持非拷贝able或非移动able类型：有些类型可能没有定义拷贝构造函数或移动构造函数，但它们可以通过其他方式构造。使用emplace接口，可以直接在容器中构造这些类型的对象。

总的来说，emplace系列接口提供了一种更高效、更直接的方式来在容器中构造对象，特别是在涉及复杂对象或需要避免不必要的拷贝/移动操作时。

10 lambda表达式

10.1 C++98 中的一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法

#include <algorithm>
#include <functional>
int main()
{
int array[] = {4,1,8,5,3,7,0,9,2,6};
// 默认按照小于比较，排出来结果是升序
std::sort(array, array+sizeof(array)/sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则：

struct Goods
{
 string _name;  // 名字
 double _price; // 价格
 int _evaluate; // 评价
 Goods(const char* str, double price, int evaluate)
 :_name(str)
 , _price(price)
 , _evaluate(evaluate)
 {}
};
struct ComparePriceLess
{
 bool operator()(const Goods& gl, const Goods& gr)
 {
 return gl._price < gr._price;
 }
};
struct ComparePriceGreater
{
 bool operator()(const Goods& gl, const Goods& gr)
 {
 return gl._price > gr._price;
 }
};
int main()
{
 vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };
 sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
}

核心逻辑就是将两个数据，不断传入仿函数对象，用返回值进行排序。

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，

都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，

这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

10.2 lambda 表达式

int main()
{
 vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price < g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price > g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate < g2._evaluate; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate > g2._evaluate; });
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函

数对象。

10.3 lambda 表达式语法

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement

}

1. lambda表达式各部分说明

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda

函数使用。

(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。

->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回

值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推

导。（不要忘记->，不屑返回类型->可以不写，写了返回类型->必须写！）

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

        

int main()
{
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
   []{}; 
    
    // 省略参数列表和返回值类型，返回值类型由编译器推导为int
    int a = 3, b = 4;
   [=]{return a + 3; }; 
    
    // 省略了返回值类型，无返回值类型
    auto fun1 = [&](int c){b = a + c; }; 
    fun1(10)
    cout<<a<<" "<<b<<endl;
    
    // 各部分都很完善的lambda函数
    auto fun2 = [=, &b](int c)->int{return b += a+ c; }; 
    cout<<fun2(10)<<endl;
    
    // 复制捕捉x
    int x = 10;
    auto add_x = [x](int a) mutable { x *= 2; return a + x; }; 
    cout << add_x(10) << endl; 
    return 0;
}

通过上述例子可以看出， lambda 表达式实际上可以理解为 无名函数对象 ，该函数无法直接调

用， 如果想要直接调用，可借助auto将其赋值给一个变量 。、

auto fun1 = [&](int c){b = a + c; }; 这样fun1就是一个可调用对象

2. 捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

[var]：表示值传递方式捕捉变量var

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

[this]：表示值传递方式捕捉当前的this指针

注意：

a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。

比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。( 在函数外部（例如全局作用域）定义的lambda不能捕获任何局部变量，因为lambda没有定义在任何函数的块作用域内)（只能父，不能爷！）

由于func参数中有一个隐藏的this指针，所以可以捕获this。可以捕捉this，也可以写 = （=替代this）

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者

非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同

void (*PF)();
int main()
{
 auto f1 = []{cout << "hello world" << endl; };
 auto f2 = []{cout << "hello world" << endl; };
    // 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
 //f1 = f2;   // 编译失败--->提示找不到operator=()
    // 允许使用一个lambda表达式拷贝构造一个新的副本
 auto f3(f2);
 f3();
 // 可以将lambda表达式赋值给相同类型的函数指针
 PF = f2;
 PF();
 return 0;
}
class Rate
{
public:
 Rate(double rate): _rate(rate)
 {}
 double operator()(double money, int year)
 { return money * _rate * year;}
private:
 double _rate;
};
int main()
{
// 函数对象
 double rate = 0.49;
 Rate r1(rate);
 r1(10000, 2);
// lamber
 auto r2 = [=](double monty, int year)->double{return monty*rate*year; 
};
 r2(10000, 2);
 return 0;
比

lambda与uuid

Lambda的类型

Lambda表达式的类型是匿名的，但是每个lambda表达式都有一个唯一的闭包类型（closure type）。你不能直接写出这个类型的名字，但是你可以使用auto关键字来自动推导类型，或者使用decltype来获取类型。

例如：

auto l = [] { return 42; };

decltype(l) anotherL = [] { return 42; };

在这个例子中，l和anotherL具有相同的闭包类型。

UUID（Universally Unique Identifier）

UUID是一个128位的数字，用于唯一标识信息。在C++中，你可以使用第三方库如Boost的uuid库来生成和使用UUID，或者在C++17及以后的版本中使用标准库中的<random>和<array>来生成UUID。

以下是一个使用C++标准库生成UUID的简单例子：

#include <random>

#include <array>

#include <iostream>

#include <sstream>



std::string generate_uuid() {

    std::random_device rd;

    std::mt19937 gen(rd());

    std::uniform_int_distribution<> dis(0, 15);



    std::array<int, 36> uuid{};

    const char *hex_digits = "0123456789abcdef";



    // 生成UUID的32个十六进制数字

    for (int &i : uuid) {

        i = hex_digits[dis(gen)];

    }



    // UUID的某些位置需要固定的字符

    uuid[8] = '-';

    uuid[13] = '-';

    uuid[18] = '-';

    uuid[23] = '-';



    // UUID的版本号（4表示随机生成）

    uuid[14] = '4';



    // UUID的变体（10xx表示标准布局）

    uuid[19] = hex_digits[(dis(gen) & 0x3) | 0x8];



    std::stringstream ss;

    for (int i : uuid) {

        ss << static_cast<char>(i);

    }



    return ss.str();

}



int main() {

    std::cout << generate_uuid() << std::endl;

    return 0;

}

请注意，上面的代码示例并不是一个完全符合UUID规范的生成器，它只是为了展示如何生成一个看起来像UUID的字符串。在实际应用中，建议使用专门的库来生成UUID，以确保其唯一性和符合标准。

mutable关键字

捕获列表：可以捕获本作用于的变量，传值捕获的变量可以用，但是不能修改（const属性）

参数后面加一个mutable（可变的）就可以。再次调用就不需要传参，可以直接使用捕获列表捕获的参数，但事实传值捕捉所以不能修改。也就是说参数列表的xy和外面的xy并不是一个xy。只不过在内部可以修改xy

传引用捕捉

如果想捕捉地址，只能外部新建一个指针，再捕捉这个指针 。引用捕捉不需要加mutable，同时可以实现修改。

mutable是与形参捕捉配合的，引用捕捉不需要mutable。

mutable可以去掉捕捉列表捕捉形参的const属性，对于引用捕获的参数，不需要mutable就可以修改参数，同时可以修改掉对应的实参

10.4 函数对象与 lambda 表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的

类对象。

int main()
{
// 函数对象
 double rate = 0.49;
 Rate r1(rate);
 r1(10000, 2);
// lamber
 auto r2 = [=](double monty, int year)->double{return monty*rate*year; 
};
 r2(10000, 2);
 return 0;
}

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

11 包装器

function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

那么我们来看看，我们为什么需要function呢？

CPP有三个可在外部调用的对象

ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么呢？我们继续往下看
template<class F, class T>
T useF(F f, T x)
{
 static int count = 0;
 cout << "count:" << ++count << endl;
 cout << "count:" << &count << endl;
 return f(x);
}
double f(double i)
{
 return i / 2;
}
struct Functor
{
 double operator()(double d)
 {
 return d / 3;
 }
};
int main()
{
// 函数名
 cout << useF(f, 11.11) << endl;
 // 函数对象
 cout << useF(Functor(), 11.11) << endl;
 // lamber表达式
 cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
 return 0;
}

 通过上面的程序验证，我们会发现useF函数模板实例化了三份。包装器可以很好的解决上面的问题

std::function 在头文件 < functional >

// 类模板原型如下

template < class T > function ;     // undefined

template < class Ret , class ... Args >

class function < Ret ( Args ...) > ;

模板参数说明：

Ret : 被调用函数的返回类型

Args… ：被调用函数的形参

在使用时，function<返回类型（参数列表）>        进行包装，参数列表是一个参数包

// 使用方法如下：
#include <functional>
int f(int a, int b)
{
 return a + b;
}
struct Functor
{
public:
 int operator() (int a, int b)
 {
 return a + b;
 }
};
class Plus
{
public:
 static int plusi(int a, int b)
 {
 return a + b;
 }
 double plusd(double a, double b)
 {
 return a + b;
 }
};
int main()
{
 // 函数名(函数指针)
 std::function<int(int, int)> func1 = f;
 cout << func1(1, 2) << endl;
 // 函数对象
 std::function<int(int, int)> func2 = Functor();
 cout << func2(1, 2) << endl;
 // lamber表达式
 std::function<int(int, int)> func3 = [](const int a, const int b) 
{return a + b; };
 cout << func3(1, 2) << endl;
 
 // 类的成员函数
 std::function<int(int, int)> func4 = &Plus::plusi;
 cout << func4(1, 2) << endl;
 std::function<double(Plus, double, double)> func5 = &Plus::plusd;
 cout << func5(Plus(), 1.1, 2.2) << endl;
 return 0;
}

有了包装器，如何解决模板的效率低下，实例化多份的问题呢？

#include <functional>
template<class F, class T>
T useF(F f, T x)
{
 static int count = 0;
 cout << "count:" << ++count << endl;
 cout << "count:" << &count << endl;
 return f(x);
}
double f(double i)
{
 return i / 2;
}
struct Functor
{
 double operator()(double d)
 {
 return d / 3;
 }
};
int main()
{
// 函数名
 std::function<double(double)> func1 = f;
 cout << useF(func1, 11.11) << endl;
 // 函数对象
 std::function<double(double)> func2 = Functor();
 cout << useF(func2, 11.11) << endl;
 // lamber表达式
 std::function<double(double)> func3 = [](double d)->double{ return d /
4; };
 cout << useF(func3, 11.11) << endl;
 return 0;
}

被包装器包装过的函数指针、匿名对象、lambda表达式就像是有了类型的对象，可以使用模板参数进行接收。

传入function包装对象之后，可以直接传入function对象使用。function对象的使用方式是

function对象 （参数列表）

这行代码将参数列表传入被对象包装的可调用对象，执行可调用对象（被包装对象）的功能。

T useF(F f, T x)
{
 static int count = 0;
 cout << "count:" << ++count << endl;
 cout << "count:" << &count << endl;
 return f(x);
}

第一行没报错，是因为静态成员没有this指针

但是还是报错，因为类型少了一个this指针

应该额外传一个plus*

使用的时候也应该传入一个对象的地址。

但是不可以写匿名对象。因为匿名对象是右值（匿名对象、临时对象），不能取地址（右值不能取地址）

后来针对匿名对象不能去地址，在这个地方又做了改动。

传参可以不用传this指针类型，传对象类型就可以。这样在使用时，就可以直接使用匿名对象进行包装器的使用

function包装器在sort的应用

void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);        //不需要传入被排序的对象，只需要传入数据迭代器

sort函数的comp的比较方式，是调用comp（*first， *last）比较，那这样的话，comp也可以是一个function包装过的匿名函数，在comp传入一个function对象就可以。(注意：传入的是对象，由函数内部自动调用：  比较对象（*first， *last））

#include <algorithm> // std::sort
#include <vector>    // std::vector

int main() {
    std::vector<int> v = {3, 1, 4, 1, 5, 9};

    // 使用 lambda 表达式作为比较函数，按降序排序
    std::sort(v.begin(), v.end(), [](int a, int b) {
        return a > b; // 如果要降序排序，返回 a 是否大于 b
    });

    // 输出排序后的 vector
    for (int i : v) {
        std::cout << i << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，[](int a, int b) { return a > b; } 是一个 lambda 表达式，它定义了一个匿名函数，该函数接受两个整数参数 a 和 b，并返回一个布尔值，表示是否应该将 a 排在 b 前面。这个 lambda 表达式被用作 std::sort 的 comp 参数，实现了降序排序。

12.bind函数

std::bind函数定义在<functional>头文件中，是一个 函数模板 ，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：

template < class Fn , class ... Args >

/* unspecified */ bind ( Fn && fn , Args && ... args );

// with return type (2)

template < class Ret , class Fn , class ... Args >

/* unspecified */ bind ( Fn && fn , Args && ... args );

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对

象来“适应”原对象的参数列表。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象（可以让function包装），arg_list是一个逗号分隔的参数列表，对应给定的

callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中

的参数。callable是一个可调用对象

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”（placeholders），表示

newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对

象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

int main()
{
 //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
 std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, 
placeholders::_2);
 //auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
 //func2的类型为 function<void(int, int, int)> 与func1类型一样
 //表示绑定函数 plus 的第一，二为： 1， 2
 auto  func2 = std::bind(Plus, 1, 2);   
 cout << func1(1, 2) << endl;
cout << func2() << endl;
 Sub s;
 // 绑定成员函数
 std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, 
placeholders::_1, placeholders::_2);
 // 参数调换顺序
 std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
placeholders::_2, placeholders::_1);
 cout << func3(1, 2) << endl; 
 cout << func4(1, 2) << endl;
 return 0;
}

func1（1，2）本质是调用Plus（1，2)同时1的占位是_1（对应第一个参数），2的占位是_2（对应第二个参数）

func3本质是调用的sub函数，函数参数的顺序是（sub，1，2)

func4(1,2）的本质就是sub（s，2，1)

这里的bind返回的新的可调用对象返回类型不变是int，参数列表变成了int，int 。

sort的comp指的就是一个可以进行数据比较的可调用对象

常见的被封装的可调用对象包括：1.函数指针 2.重载operator（）的匿名对象 3.lambda表达式