一、C++11简介
在2003年C++标准委员会曾经提交了一份技术勘误表（简称CT1），使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03主要是对C++98标准中的漏洞进行修复，语言的核心部分并没有改动，因此人们习惯的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准十年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出来的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用的比较多。
二、统一的列表初始化
1、{}初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
struct A
{
int _a1;
int _a2;
};
void Test1()
{
int arr[] = { 1,2,3,4,5,6 };//对数组用列表初始化
A A1 = { 1,100 };//对结构体用列表初始化
cout 
C++11扩大了用大括号括起来的列表（初始化列表）的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用列表初始化时，可添加等号（=），也可不添加。
struct A
{
int _a1;
int _a2;
};
void Test1()
{
int arr[]{ 1,2,3,4,5,6 };
int x{ 3 };
A A1{ 1,100 };//对结构体用列表初始化
cout 
创建对象时也可以使用列表初始化方式调用构造函数初始化
struct Date
{
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{
cout 
2、std::initializer_list
请问下面的Date的列表初始化和vector、list的列表初始化是一样的吗
Date d1{ 2003,10,27 };
vector v = { 1,2,3,4,5,6 };
list lt = { 10,20,30,100 };答案是不是一样的，Date的这个列表初始化本质上是一种类型转换，用三个数字生成临时Date变量，再用临时Date变量拷贝构造d1，所以d1的列表初始化里数据的个数必须和构造函数参数的个数一样。而v和lt列表初始化里数据的个数则是可以随便给多少都行。显然两者并不一样。
那么vector和list是如何实现的呢？其实vector和list里都实现了用initializer_list对象来初始化的构造函数。
std::initializer_list文档介绍
C++11做了特殊处理，当列表初始化里的数据个数与构造函数的参数个数不同时，会把列表初始化的数据识别为initializer_list对象。
我们自己写的类如果也想要实现这种效果，只需要实现用initializer_list对象来初始化的构造函数即可。
struct TestVector//测试
{
TestVector(initializer_list lt)
:_p(new int[10])
{
int i = 0;
for (auto a : lt)//initializer_list实现了迭代器，所以可以用范围for
{
_p[i++] = a;
}
for (int j = 0;j 
三、声明
C++11提供了多种简化声明的方式，尤其是在使用模板时。
1、auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto没有什么价值。C++11中废弃了auto原来的用法，将其用于实现自动类型判断。这样要求必须实现显示初始化，让编译器将定义对象的类型设置为初始值的类型。
void Test4()
{
int i = 10;
auto p = &i;
auto pf = strcpy;
cout dict = { {"sort", "排序"}, {"insert", "插入"} };
//map::iterator it = dict.begin();
auto it = dict.begin();//使用auto能更加方便简易
}
2、decltype
关键字decltype将变量的类型声明为表达式指定的类型。
decltype的出现弥补了auto的一个不足，虽然auto可以自动判断类型，但是无法用auto来定义变量。
void Test5()
{
auto a = 1.13;
auto b = 2;
decltype(a) c;//a的类型为double
cout dict = { {"sort", "排序"}, {"insert", "插入"} };
//map::iterator it = dict.begin();
auto it = dict.begin();//auto虽然自动判断了类型
//那么如何定义一个相同类型的变量呢？
decltype(it) it2;//用decltype
}
3、nullptr
用于C++中NULL被定义成字面量0，这样就可能会引发一些问题，因为0既能表示指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif四、STL中的一些变化
1、新容器
用红色边框圈起来的是C++11中的几个新容器，实际最有用的是unordered_map和unordered_set。
2、容器中的一些新方法
基本每个容器都增加了一些C++11的方法，但很多其实用不上。
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。
实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本：
。。。。。
五、右值引用与移动语义
1、左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了右值引用语法特性。无论左值引用还是右值引用，都是给对象取别名。
什么是左值？什么是左值引用？
左值是一个表示数据的表达式（如变量名或解引用的指针），我们可以获取它的地址，并且可以对其赋值，左值可以出现在赋值符号的左边或右边。定义
const修饰的左值，虽然不能给它赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
void Test6()
{
// 以下的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;
}什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值、函数返回值（这个返回值不能是左值引用返回），右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
void Test7()
{
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 : E0137 表达式必须是可修改的左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
//下面编译会报错: error : E0158 表达式必须为左值或函数指示符
&10;
&(x + y);
&(fmin(x, y));
}需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面常量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1去引用。右值引用其实是左值，例如下面的rr1是左值。不过实际中右值引用的使用场景并不在此，这个特性也不重要。
void Test8()
{
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
//可以给右值有用取地址
&rr1;
&rr2;
rr1 = 20;
rr2 = 5.5; // 报错
}2、左值引用与右值引用比较
左值引用总结：
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可以引用左值，也可以引用右值。
void Test9()
{
int a = 10;
//左值引用只能引用左值,不能引用右值
int& ra1 = a;
int& ra2 = 10;//报错，因为10是右值
//const引用既能引用左值，又能引用右值
const int& ra3 = a;
const int& ra4 = 10;
}右值引用总结：
- 右值引用只能引用右值，不能引用左值。
- 但是右值引用可以引用move以后的左值。
void Test10()
{
// 右值引用只能右值，不能引用左值。
int&& r1 = 10;
int a = 10;
int&& r2 = a;//报错
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
}3、右值引用的使用场景和意义
上面看到了，左值引用既可以引用左值，又可以引用右值，那为什么C++11还要提出右值引用呢？其实左值引用有一个短板，右值引用就是用来弥补这个短板的。
简易string：
namespace lsx
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
//cout _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '';
}
//string operator+=(char ch)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的
};
}左值引用的使用场景：
做参数和做返回值都可以提高效率
void func1(lsx::string s)//值传递
{}
void func2(lsx::string& s)//引用传递
{}
void Test11()
{
lsx::string s = "hello world";
// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
func1(s);//会有深拷贝
func2(s);
// string operator+=(char ch) 传值返回存在深拷贝,效率低下
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
s += '2';
}
左值引用的短板：
当函数返回的对象是一个局部变量时，出了作用域就不存在了，就不能使用左值引用返回，只能传值返回。传值返回就会导致深拷贝，效率降低。
lsx::string To_String(int value)//传值返回
{
lsx::string ret;
while (value)
{
int tmp = value % 10;
value /= 10;
ret += ('0' + tmp);
}
reverse(ret.begin(), ret.end());
int i = 2;
return ret;
}
void Test13()
{
lsx::string s1 = To_String(123);
}
右值引用和移动语义解决上述问题：
在lsx::string中增加移动构造，移动构造的本质就是将参数右值的资源夺取过来，占为己有，那么就不需要深拷贝了，所以叫它移动构造，就是夺取别人的资源来构造自己。
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
swap(s);//不会进行深拷贝，直接夺取s的资源
}普通构造的过程：
移动构造的过程：
不仅有移动构造，还有移动赋值：
// 移动赋值
string& operator=(string&& s)
{
swap(s);
return *this;
}STL中的容器都增加了移动构造和移动赋值：
4、右值引用引用左值及其一些更深入的使用场景
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：在某些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以用move函数将左值转化为右值。该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
void Test14()
{
lsx::string s1;
//s1是左值，这里调用的是拷贝构造
lsx::string s2(s1);
//move(s1)是右值，这里调用的是移动构造
//但是调用移动构造后，s1的资源被s3夺走了，s1就空了
//所以一般不建议这么做
lsx::string s3(move(s1));
}STL容器插入接口函数也增加了右值引用版本：
5、完美转发
模板中的&&万能引用：
模板中的&&不代表右值引用，而代表万能引用，既能接收左值又能接受右值。
void Fun(int& x) { cout
void PerfectForward(T&& t)
{
//t虽然可能引用右值，但是不管是右值引用还是左值引用，都是左值
//也就是说t一定是左值
//这不是我们想要的效果，需要思考如何解决这问题。
Fun(t);
}
void Test15()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
}
void Fun(int& x) { cout
void PerfectForward(T&& t)
{
//此时就需要使用完美转发，保持实参的属性
Fun(forward(t));
}
void Test15()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
}
完美转发的实际使用场景：
简易实现一个list，实现了Insert的右值引用版本，在PushBack和PushFront接口用了万能引用，并用完美转发保持实参的属性。
template
class List//链表
{
typedef ListNode Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(T&& x)
{
//完美转发，保持x的属性
Insert(_head, forward(x));
}
void PushFront(T&& x)
{
Insert(_head->_next, std::forward(x));
}
void Insert(Node* pos, T&& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node;
newnode->_data = std::forward(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;
};六、新的类功能服务器托管网
1、新增默认成员函数
原来的C++类中，有6个默认成员函数：
- 构造函数
- 析构函数
- 拷贝构造函数
- 赋值重载
- 取地址重载
- const取地址重载
最重要的是前面4个，后面2个用处不大。默认成员函数就是如果自己不写编译器会生成一个默认的。
C++11新增了两个默认成员函数：移动构造函数和移动赋值重载。
针对移动构造函数和移动赋值重载有以下几点需要注意：
- 如果没有自己实现移动构造函数，并且没有实现析构函数、拷贝构造函数、赋值重载中的任意一个。那么编译器会自动生成一个默认的移动构造函数。默认生成的移动构造函数，对于内置类型成员会执行逐成员逐字节拷贝，对于自定义类型成员，则需要看这个成员是否实现了移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果没有自己实现移动赋值重载，并且没有实现析构函数、拷贝构造函数、赋值重载中的任意一个。那么编译器就会自动生成默认移动赋值重载。默认生成的移动赋值重载，对于内置类型成员会执行逐成员逐字节拷贝，对于自定义类型成员，则需要看这个成员是否实现了移动赋值重载，如果实现了就调用移动赋值重载，没有实现就调用赋值重载。（默认生成的移动赋值重载和默认生成的移动构造规则完全类似）
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:
lsx::string _name;//lsx::string类实现了移动构造与移动赋值重载
int _age;
};
void Test16()
{
Person s1;
Person s2 = s1;//赋值重载
//Person有默认生成的移动构造和移动赋值重载
//因为没有自己实现拷贝构造、赋值重载、析构
Person s3 = move(s1);//移动构造
Person s4;
s4 = move(s2);//移动赋值重载
}
2、强制生成默认函数的关键字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& operator=(const Person& p)//赋值重载
{
if (this != &p)
{
_name = p._name;
_age = p._age;
}
return *this;
}
~Person()//析构
{}
//强制生成默认的移动构造与移动赋值重载
Person(Person&& p) = default;//移动构造
Person& operator=(Person&& p) = default;//移动赋值重载
private:
lsx::string _name;//lsx::string类实现了移动构造与移动赋值重载
int _age;
};
void Test16()
{
Person s1;
Person s2 = s1;//赋值重载
Person s3 = move(s1);//移动构造
Person s4;
s4 = move(s2);//移动赋值重载
}3、禁止生成默认构造函数的关键字delete
如果想要限制某些默认函数的生成。在C++98中，是将该函数设置为private，只要其他人想要调用就会报错。在C++11中更简单，只需要在该函数声明加上delete即可，该语法指示编译器不生成对应函数的默认版本。
class Person
{
public:
Person(const char* name = "", int age = 0)//构造函数
:_name(name)
, _age(age)
{}
~Person()//析构
{}
//强制删除移动构造
Person(Person&& p) = delete;//移动构造
Person(const Person& p) = default;//拷贝构造
private:
lsx::string _name;//lsx::string类实现了移动构造与移动赋值重载
int _age;
};
void Test16()
{
Person s1;
Person s2 = s1;//赋值重载
Person s3 (s1);//移动构造
Person s4;
s4 = move(s2);//报错，使用已被删除的函数
}七、可变参数模板
C++11的新特性可变参数模板能够让我们创建可接受可变参数的函数模板和类模板，相比C++98/03，类模板和函数模板中只能包含固定数量的模板参数，可变模板参数无疑是一个巨大的改进。然后由于可变模板参数比较抽象，使用起来需要一定的技巧，这里的知识比较晦涩。
下面就是一个基本的可变参数的函数模板：
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template
void ShowList(Args... args)
{}以下面的方式计算参数包的参数个数：
template
void ShowList(Args... args)
{
cout 
上面的参数args前面有省略号，所以它就是一个可变模板参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模板参数。我们无法直接获取参数包args中的每一个参数，只能通过展开参数包的方式来获取参数包中的每个参数，这个是使用可变模板参数的一个主要特点，也是最大的难点，即如何展开可变模板参数。由于语法不支持用args[i]这样的方式获取可变参数，所以我们需要用一些奇招来一一获取参数包中的每个参数。
1、递归函数方式展开参数包
void _ShowList()
{
cout
void _ShowList(const T& val,Args... args)
{
cout
void ShowList(Args... args)
{
_ShowList(args...);
}
void Test17()
{
ShowList('x', 1899, "Milan", 3.14);
}
原理如下：
2、逗号表达式展开参数包
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的，PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开的方式实现的关键是逗号表达式。因为逗号表达式会按顺序执行逗号表达式前面的表达式。
expand函数中的逗号表达式，(PrintArg(args),0)，也是按照这个执行顺序，先执行PrintArg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另一个特性——列表初始化，通过列表初始化来初始化一个变长数组，{(PrintArg(args),0)…}将会被展开成{(PrintArg(args1),0),(PrintArg(args2),0),(PrintArg(args3),0),…}。最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行前面的PrintArg(args)部分打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
//逗号表达式展开
template
void PrintArg(T t)
{
cout
void ShowList(Args... args)
{
服务器托管网int arr[] = { (PrintArg(args), 0)... };
cout 
3、STL中的emplace相关接口
emplace系列接口支持模板的可变参数，并且万能引用。
在一般情况下emplace_back和push_back没有差别差别：
void Test19()
{
std::list lt;
lsx::string s1("1111");
lt.push_back(s1);
lt.push_back(move(s1));
cout 
下面演示了emplace_back和push_back有差别的情况：
void Test20()
{
std::list lt;
lt.push_back("xxxx");
cout 
虽然有push_back比emplace_back多调用了一次移动构造，不过其实没什么影响。
其他差别：
void Test21()
{
std::list > 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 
八、lambda表达式
1、C++98中的一个例子
在C++98中，如果想要对一组数据中的元素进行排序，可以用std::sort方法。
void Test22()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
sort(array, array + sizeof(array) / sizeof(array[0]));
for (auto a : array) { cout ()
sort(array, array + sizeof(array) / sizeof(array[0]), greater());
for (auto a : array) { cout 
如果待排序元素为自定义类型，需要用户自己定义排序时的比较规则（仿函数）：
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;
}
};
void Test23()
{
vector 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表达式。
2、lambda表达式的使用
void Test24()
{
vector 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._evaluate g2._evaluate; });
}上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数对象。
3、lambda表达式的语法
（1）lambda表达式的书写格式：
[capture-list] (parameters) mutable -> return-type {statement}
lambda表达式各部分说明：
- [capture-list]：捕捉列表。该列表总是出现在lambda表达式的开始位置，编译器根据[]来判断接下来的代码是否为lambda表达式，捕捉列表能够捕捉上下文中的变量供lambda表达式使用。
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要传递参数，可以连同()一起省略。
- mutable：默认情况下，lambda表达式总是具有常性，mutable可以取消其常量属性。使用该修饰符时，参数列表不能省略（即使参数为空）。
- ->return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确的情况下，也可省略，由编译器对返回类型进行推导。
- {statsment}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：在lambda表达式中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda表达式为：[]{}，该lambda表达式不能做任何事。
例子：
void Test25()
{
auto f1 = [](int x)->int {cout 
lambda表达式可以理解成一个无名函数对象，该函数对象无法直接调用，如果想要调用，需要借助auto将其赋值给一个变量。
（2）捕捉列表说明：
捕捉列表描述了上下文中哪些数据可以被lambda表达式使用，以及使用的方式传值还是传引用。
- [var]：表示值传递方式捕捉变量var。
- [=]：表示值传递方式捕捉父作用域中的所有变量（包括this）。
- [&var]：表示引用传递方式捕捉变量var。
- [&]：表示引用传递方式捕捉父作用域中的所有变量（包括this）。
- [this]：表示值传递方式捕捉当前的this指针。
注意：
- 父作用域指的是包含lambda表达式的语句块。
- 捕捉列表可以由多个捕捉项组成，并用逗号分割。
比如：[=,&a,&b] 以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。[&,a,this] 值传递方式捕捉变量a和this，引用方式捕捉其他变量。
- 捕捉列表不允许变量重复传递。
比如：[=, a] =已经以值传递方式捕捉了所有变量，捕捉a重复。
- 在块作用域以外的lambda表达式捕捉列表必须为空。（全局的lambda表达式）
- 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
- lambda表达式之间不能相互赋值，即使看起来类型相同 。
示例1：
原本我们想要实现一个交换函数需要这样写：
void Test26()
{
int x = 13, y = 21;
auto f1 = [](int& x, int& y) {
int tmp = x;
x = y;
y = tmp;
};
cout 
现在可以直接用捕捉列表来实现：
void Test26()
{
int x = 13, y = 21;
auto f1 = [x, y]() {
int tmp = x;
x = y;//报错
y = tmp;//报错
};
cout 但是这样写是有问题的，会报错。被捕捉的参数，会成为lambda表达式的成员函数。然后上面我们简单提到了lambda表达式具有常性，其实是lambda表达式生成的类里的operator()方法被const修饰了，成为operator()const。这就导致了在里面成员变量是无法修改的。所以会如果我们尝试修改，就会报错。那么想要解决这个问题只需要加上mutable即可。
使用mutable后：
void Test26()
{
int x = 13, y = 21;
auto f1 = [x, y]()mutable {
int tmp = x;
x = y;
y = tmp;
};
cout 
运行结果并不对，x和y没有交换，其实是因为我们是以值传递的方式捕捉，所以并不会改变外面的x和y。
换成以引用传递的方式捕捉即可：
void Test26()
{
int x = 13, y = 21;
auto f1 = [&x, &y]()mutable {
int tmp = x;
x = y;
y = tmp;
};
cout 
补充一点，引用传递方式捕捉的参数，其实不用加mutable也能修改，这其实是进行了特殊处理。因为使用者引用传递方式捕捉就是为了要修改，那么还要加mutable就有些奇怪了。
所以值传递方式捕捉的变量时不能修改的，引用传递方式捕捉的变量时可以修改的。
void Test26()
{
int x = 13, y = 21;
auto f1 = [&x, &y]() {
int tmp = x;
x = y;
y = tmp;
};
cout 
示例2：
void Test27()
{
int x = 13, y = 21, z = 3;
auto f1 = [=, &z]() {
cout 
示例3：
class AA
{
public:
void Test()
{
auto f1 = [=]() {
//捕捉了父作用域的this指针
cout 
4、函数对象与lambda表达式。
struct Compare
{
int operator()(int x)
{
cout int {cout 
从上面可以看出，其实lambda表达式最终是会被生成一个对应的类。仿函数和lambda表达式完全一样。
在进一步通过反汇编来看：
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
九、包装器
1、function包装器
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
std::function在头文件
// 类模板原型如下
template function; // undefined
template
class function;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参类型function的包装器使用：
void Swap1(int& x,int& y)
{
int tmp = x;
x = y;
y = tmp;
}
struct Swap2
{
void operator()(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
};
void Test29()
{
auto Swap3 = [](int& x, int& y) {int tmp = x;x = y;y = tmp;};
function f1 = Swap1;//包装器包装函数指针
function f2 = Swap2();//包装器包装仿函数
function f3 = Swap3;//包装器封装lambda表达式
int x = 13, y = 21;
cout 
虽然函数指针，仿函数，lambda表达式是三种不同的类型，但是我们用包装器包装后的f1、f2、f3是同类型的。因此我们可以实现下面这种调用方法：
void Test29()
{
auto Swap3 = [](int& x, int& y) {int tmp = x;x = y;y = tmp;};
function f1 = Swap1;//包装器包装函数指针
function f2 = Swap2();//包装器包装仿函数
function f3 = Swap3;//包装器封装lambda表达式
map> cmdOP = {
{"函数指针",f1},
{"仿函数",f2},
{"lambda表达式",f3}
};
int x = 13, y = 21;
cout 包装成员函数：
struct Plus
{
static int plusi(int x, int y)
{
return x + y;
}
double plusd(double x, double y)
{
return x + y;
}
};
void Test30()
{
//成员函数取地址比较特殊，需要加类域和&
function f1 = Plus::plusi;//静态成员函数不用加&
cout f2 = &Plus::plusd;
//但是上面这样写会报错
//因为参数类型不匹配，plusd函数还有一个隐藏的参数this指针
function f2 = &Plus::plusd;//这样写就对了
Plus p;
cout f3 = &Plus::plusd;//这样写就对了
cout 
2、bind包装器
bind是一个函数模板，它就像一个函数包装器（适配器），接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们可以把一个原本接收N各参数的函数fn，通过绑定一些参数，返回一个接收M个参数的新函数（M可以大于N，但这样做没什么意义）。同时，使用bind函数还可以实现参数顺序调整等操作。
// 原型如下：
template
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template
/* unspecified */ bind (Fn&& fn, Args&&... args);调用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的使用：
调整参数顺序：
void Test31()
{
function f1 = sub;
cout f2 = bind(sub, placeholders::_2, placeholders::_1);
cout 
调整参数个数：
void Test31()
{
function f1 = sub;
cout f2 = bind(sub, 20, placeholders::_1);
cout 
解决上面的绑定成员函数问题：
void Test32()
{
function f3 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);
cout 
完结。。。。。。。
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.fwqtg.net
【直播预告】替代 Oracle，我们还有多长的路要走？ 大模型对技术界带来的冲击服务器托管网与革新已无需赘述，但实际上，业界也一直有个声音认为大模型技术本质上并不是什么大的进步，也无法解决所有问题。而纵观当下技术人的的选择，一方面，我们能看到大家正在积极拥抱大…
