当前位置：首页 > news >正文

C++11新特性全面解析（万字详解）

news 2025/8/25 14:00:03

1.C++11简介

2. 列表初始化

2.1 ｛｝初始化

2.2 std::initializer_list

3. 声明

3.1 auto

3.2 decltype

3.3 nullptr

4. 范围for循环

5. ﬁnal与override

6. 智能指针

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

8. 默认成员函数控制

9. 右值引用

1 左值引用和右值引用

2.左值引用与右值引用比较

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

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

5 万能引用与完美转发

10.可变参数模板

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

递归函数方式展开参数包

逗号表达式展开参数包（就地展开）

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

10. lambda表达式

10.1 C++98中的一个例子

10.2 lambda表达式

10.3 lambda表达式语法

10.4 函数对象与lambda表达式

11.包装器

function包装器

bind包装器

基本用法

绑定成员函数

参数重排

function包装器和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能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一一讲解，所以本节课程主要讲解实际中比较实用的语法。

小故事： 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

std::initializer_list使用场景：

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator= 的参数，这样就可以用大括号赋值。我们用的绝大部分容器，都支持{}初始化和赋值，比如：

nt main()
{vector<int> v = { 1,2,3,4 };list<int> lt = { 1,2 };// 这里{"sort", "排序"}会先初始化构造一个pair对象map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };// 使用大括号对容器赋值v = {10, 20, 30};return 0;
}

{1,2,3,4}被编译器解释为 std::initializer_list<int> 类型的临时对象，然后调用构造函数；

因此，在函数的返回值或形参是一个支持{}赋值的类型时，我们就可以返回（传入）一个{}；

补充：能用{}初始化的类型，也可以用{}创建临时对象，比如vector 就可以用{begin,end}创建；

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将变量的类型声明为表达式指定的类型。

// 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的类型是doubledecltype(&x) p;      // p的类型是int*cout << typeid(ret).name() << endl;cout << typeid(p).name() << endl;F(1, 'a');return 0;
}

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-＞C++核心过渡语法精讲与实战-CSDN博客

5. ﬁnal与override

（1） final关键字可以修饰类和虚函数：

修饰类：表示该类不能被继承，例如：

   class final_class final {// 不能被继承};

修饰虚函数：表示该虚函数不能在派生类中被重写，例如：

   class base_class {public:virtual void func() final {// 不能被重写}};

（2）override关键字用于明确表示派生类中的成员函数覆盖了基类中的虚函数，通过使用override，可以清晰地表明该函数是作为虚函数覆盖了基类中的同签名函数。override能确保虚函数被重写。

6. 智能指针（暂不做介绍）

在后面的博客中会专门讲解……

7. 新增加容器---array、forward_list以及unordered系列（简单了解）

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和 unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解一下即可。

8. 默认成员函数控制

在C++11中，默认成员函数的控制得到了显著增强，引入了default和delete关键字，以及移动语义相关的函数。以下是关键内容：

1.default关键字：强制编译器生成默认实现的成员函数，适用于需要默认行为但显式声明的情况

   class MyClass {public:MyClass() = default; // 强制生成默认构造函数};

2.delete关键字：禁止编译器自动生成特定成员函数，防止隐式调用

   class MyClass {public:MyClass(const MyClass&) = delete; // 禁止拷贝构造};

9. 右值引用

1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

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

左值（Lvalue，locator value）是指在内存中有持久地址的表达式，简单来说：

有持久内存地址：左值在程序执行期间会持续存在（局部和全局都可以）
可以取地址：可以使用&运算符获取其地址
可修改的左值：大多数左值是可以被修改的（除了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;
}

左值引用是变量的别名，它必须绑定到左值：

语法：类型& 引用名 = 左值表达式;
必须初始化：声明时必须初始化
绑定规则：只能绑定到左值，不能绑定到右值

左值引用的主要用途包括：

函数参数传递（避免拷贝）
函数返回值引用（返回局部变量时要小心）

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

右值（Rvalue，read-only value）是指：

没有持久内存地址的表达式，是具有“常性”的数据
不能出现在赋值运算符的左侧
通常表示临时对象或字面量，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等

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;
}

2.左值引用与右值引用比较

如果表达式有名称、可以取地址，通常是左值
如果表达式是字面量、临时对象、计算结果，通常是右值
函数返回值如果是非引用类型，通常是右值
左值引用只能引用左值，不能引用右值，但是const左值引用既可引用左值，也可引用右值
右值引用只能右值，不能引用左值，但是右值引用可以move以后的左值。

int&& r3 = std::move(a);

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

右值引用主要应用于移动语义上：

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

下面给出string类容器模拟实现代码中的拷贝构造和赋值重载，参数用左值和右值引用的对比分析：

// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}// 移动构造string(string&& s):_str(nullptr),_size(0),_capacity(0){cout << "string(string&& s) -- 移动语义" << endl;swap(s);}// 移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动语义" << endl;swap(s);return *this;}

假设此时有一个func函数的返回值是内部的局部string对象，那么返回的就是右值；

这个时候如果用string的拷贝构造或赋值重载来接收func的返回值，会发生什么呢？

首先，拷贝构造和赋值重载的思路都是交换资源！但是如果是const左值引用作为参数，你根本不知道你接受的是左值还是右值！如果是左值，那你是不能直接交换的，而是要构造一个临时string（深拷贝）再交换，但是如果是右值就可以直接交换啊！这样不就在接收右值的情况下多了一次构造（深拷贝）吗？？

因此，用const左值引用作为参数会浪费右值的简单处理情况，导致多构造一次；

理想情况应该是这样的：当接收左值的时候，采用构造临时对象再交换的做法；接收右值的时候，直接交换就可以了！

所以我们要多重载一个接收右值的拷贝构造和赋值重载，如图中代码所示，这叫移动构造和移动赋值！

左值引用的短板：

除了上述的const 左值引用作为形参时无法区分左值右值以外，当左值引用修饰返回值时，如果当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

移动构造的必要性：

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

在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。移动构造中没有新开空间，拷贝数据，所以效率提高了。

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

在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，这里调用的移动赋值。

总结：移动语义其实就是移动构造和移动赋值，就是用右值引用作为形参的拷贝构造和赋值重载函数，它们负责接收右值参数，对右值进行处理；移动语义大大减少了深拷贝，提高了效率！

事实上，STL中的容器都是增加了移动构造和移动赋值！

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

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::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;
}

对于下面这样一段代码：

void push_back (value_type&& val);
int main()
{list<bit::string> lt;bit::string s1("1111");// 这里调用的是拷贝构造lt.push_back(s1);// 下面调用都是移动构造lt.push_back("2222");lt.push_back(std::move(s1));return 0;
}
运行结果：
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义

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

例如图中的push_back,如果传入的是左值，就拷贝构造，如果是右值，就调用移动构造；

5 万能引用与完美转发

（1）模板中的&& 万能引用

万能引用是C11引入的一个重要概念，其语法形式为 T&&，其中T是一个模板参数。它可以同时绑定左值和右值：

template<typename T>
void PerfectForward(T&& t)
{Fun(t);
}

注意：

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

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

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

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

万能引用的缺点：虽然能够接收左值或右值，但是无法保持原有属性，都会退化成左值！

此时可能会造成不必要的拷贝，代码如下：

template<typename T>
void foo(T&& param) {std::vector<int> vec;vec.push_back(param); // 总是拷贝，即使传入右值
}

可能有人会想到用std::move将param转化成右值，但实际上，我们并不确定原本是一个左值还是右值，如果这样做，会导致参数始终为右值，导致不必要的后果（比如将左值转化为右值后，原本左值的空间资源被洗劫一空了）

（2）完美转发

完美转发使用std::forward来解决万能引用的缺点，保持原始参数的值类别：

template<typename T>
void foo(T&& param) {process(std::forward<T>(param)); // 保持原始值类别
}int main() {int x = 42;foo(x);  // process接收左值foo(42); // process接收右值
}

注意：完美转发必须与万能引用搭配使用，且不能转发局部对象！每次使用param时都要完美转发；

10.可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比 C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止。

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

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

我们可以理解为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...);
}

注意args是参数包，在参数包变量后面的...是参数包展开操作符。在这里展开表示将所有参数都传入进去；

逗号表达式展开参数包（就地展开）

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

这种展开参数包的方式，不需要通过递归终止函数，是直接在函数体中展开的, printarg 不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式，实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

函数中的逗号表达式：(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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包

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

先来了解下emplace_back的特性和原理：

emplace_back() 是 C++ 标准库中容器（如 vector、list、deque 等）的一个成员函数，它允许在容器末尾直接构造元素，而不需要先创建临时对象再复制或移动。

emplace_back() 的核心原理是就地构造：

// 基本用法
std::vector<std::string> vec;
vec.emplace_back("Hello"，“world”);  // 直接在 vector 内存中构造 string 对象

注意emplace_back的就地构造也可以是移动构造：

std::string str = "Hello";
vec.emplace_back(std::move(str)); // 这里会调用移动构造// 或者
vec.emplace_back(std::string("Hello")); // 这里也会调用移动构造

与 push_back() 的区别：

// push_back 需要创建临时对象
std::string temp("Hello");
vec.push_back(temp);  // 先构造临时对象，再复制/移动到容器中

emplace_back() 的优势：

避免不必要的拷贝/移动：直接在容器内存中构造对象
适用于不可复制类型：如 std::unique_ptr、std::future 等
性能提升：减少了临时对象的创建和销毁
可以传入多组参数，每一组参数都是该元素对象的构造函数的参数

那么emplace_back函数是怎么做到的？来看看其简单代码实现逻辑：

// 简化的实现原理
template<typename... Args>
void emplace_back(Args&&... args) {// 1. 检查是否需要扩容if (size() == capacity()) {reserve(capacity() == 0 ? 1 : capacity() * 2);}// 2. 在容器末尾直接构造对象new (data() + size()) T(std::forward<Args>(args)...);// 3. 更新大小++m_size;
}

可以看到，emplace_back用到了可变参数模版、万能引用和完美转发，有了可变参数模版，我们就可以传入n个任意类型的参数了;在底层就地改造的时候，需要调用相应的构造函数，就需要把参数包展开传递给构造函数了，并且万能引用和完美转发保证了构造函数接收的参数能保持原有的左右值属性，从而能判断应该调用普通构造还是移动构造。实际上，该函数可以构造多个元素，只不过上面代码没有体现出构造多个元素；

这样我们就能理解了emplace_back是如何通过传递多组参数，在尾部构造出多个元素的了！

除了emplace_back,还有emplace_front,emplace,

push_front() vs emplace_front():

// push_front版本
template<typename T>
void push_front(const T& value);
template<typename T>
void push_front(T&& value);// emplace_front版本
template<typename... Args>
void emplace_front(Args&&... args);

insert() vs emplace()

// insert版本
iterator insert(const_iterator pos, const T& value);
iterator insert(const_iterator pos, T&& value);// emplace版本
template<typename... Args>
iterator emplace(const_iterator pos, Args&&... args);

可见，寻常的insert系列接口有左值版本和右值版本，但它们都是先构造临时对象再拷贝进去；

而emplace系列接口通过万能引用同时能接受左值或右值，能自发选择移动构造或普通构造来就地构造，减少了拷贝，提高了效率；

注意：当元素类型为内置类型的时候，emplace系列接口和insert系列接口的效率差不多，因为内置类型拷贝成本低，但如果是涉及到深拷贝的元素类型，就是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表达式各部分说明

（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda 函数使用。

（2） (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略；

（3）mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

（4）->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

（5）{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

2. 捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。注意只能捕捉父作用域的变量！

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

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

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

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

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

注意：

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

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

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

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

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

d. 在块作用域以外的lambda函数捕捉列表必须为空。即：全局的lambda函数不能捕获任何变量。因为全局的lambda函数在任何地方都可以调用，如果它捕捉了局部变量，当局部变量已经销毁后，lambda仍然可能被调用，导致访问无效内存。也不能捕获全局变量，因为不需要捕获就能使用；

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;
}

10.4 函数对象与lambda表达式

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

看下面代码：

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);// lamberauto r2 = [=](double monty, int year)->double{return monty*rate*year; 
};r2(10000, 2);return 0;
}

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。但是lambda写起来简短；

底层上来看：

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

11.包装器

function包装器

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

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

首先，我们已经学过了很多可调用对象了，比如函数名、函数指针、函数对象（仿函数对象）、lambda表达式对象等；那么来看这样一段代码：

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时，我们会发现useF函数模板实例化了三份。

这样会导致模版的效率低下！

包装器可以很好的解决上面的问题，std::function是一个强大的工具，它提供了函数对象的通用包装器，使得函数指针、lambda表达式、成员函数等都能以统一类型的方式处理；

使用方法如下：

#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;
}

注意：普通函数可以自动将函数名转换为函数地址，但成员函数必须加&才能获取成员函数地址；所以包装器在包装类的成员函数时，需要用&类名::函数名的形式！

为什么普通函数可以转换，成员函数不能转换？

因为普通函数在内存中就是一个简单的地址，没有额外的上下文信息。而成员函数则完全不同，成员函数实际上隐藏了一个额外的参数：this指针，因此成员函数的地址信息还需要绑定一个具体的对象类型信息（用于调整this偏移），所以不能简单的转换为函数地址；（成员函数的地址包含函数地址和类对象信息）！如果是静态成员函数，就可以像普通函数一样自动转换成函数地址了。

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

#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;
}

只需要将可调用对象用包装器包装起来，然后向函数模版中传入该包装器即可，这样模版就只需要实例化一份即可！

bind包装器

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

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

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的 callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示 newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

bind的常见使用场景：

std::bind的主要使用场景包括参数绑定和创建函数对象。它可以用于将函数的一部分参数绑定到特定的值，从而创建一个参数较少的新函数。

基本用法

#include <functional>
#include <iostream>void print(int a, int b, int c) {std::cout << a << " " << b << " " << c << std::endl;
}int main() {// 绑定第一个参数为10auto bound_func = std::bind(print, 10, std::placeholders::_1, std::placeholders::_2);// 调用时只需提供后两个参数bound_func(20, 30);  // 输出: 10 20 30return 0;
}

绑定成员函数

#include <functional>
#include <iostream>class MyClass {
public:void display(int value) {std::cout << "Value: " << value << std::endl;}
};int main() {MyClass obj;// 绑定成员函数auto display_func = std::bind(&MyClass::display, &obj, std::placeholders::_1);// 调用成员函数display_func(42);  // 输出: Value: 42return 0;
}

注意，绑定成员函数时，除了必须要显示地取地址外，还要传递一个对象地址，因为成员函数的第一个形参实际是一个this指针，因此我们要手动在第一个参数位置传入类对象的地址；编译器不会自动将对象地址传给this了，因为编译器无法确定bind绑定的就是成员函数！并且调用成员函数也必须通过对象来调用才行！

当然，如果是静态成员函数，自然就不需要传入this了

参数重排

#include <functional>
#include <iostream>void process(int a, int b, int c) {std::cout << "a=" << a << ", b=" << b << ", c=" << c << std::endl;
}int main() {// 参数重排：交换b和c的位置auto rearranged = std::bind(process, std::placeholders::_1, std::placeholders::_3, std::placeholders::_2);rearranged(1, 2, 3);  // 输出: a=1, b=3, c=2return 0;
}