可以理解为一个匿名函数。和函数一样，lambda表达式具有一个返回类型、一个参数列表和一个函数体。
capture list：表示捕获列表，捕获的是lambda所在函数中定义的局部变量
parameter list：表示参数列表
return type：返回类型
function body：函数体
1. auto func = [](int a) {return a; };//捕获列表为空，即什么都不捕获
2. int b=10;
auto func = [b]() {return b; };//值捕获，仅获取值，不获取指针
3 int b=10;
auto func = [&b]() { b=99;return b; };//引用捕获，获取值，获取指针(可修改值),调用func()后，b变为99。
---------------------------------------------------------------------------------------------------
4 int i = 10;
int j = 20;
int k = 30;auto test1 = [=]() { cout <<"i为："<< i << endl <<"j为：" << j << endl<< "k为：" << k << endl; };// 捕获列表中的”=“表示，获取Lambda表达式所在函数体内的所有局部变量，叫默认值捕获，仅可获取值，不获取指针
5 int i = 10;
int j = 20;
int k = 30;auto test3 = [&]() { i=k=j = 999; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };// i，j和k的值都被修改为999，因为捕获列表中的"="表示获取Lambda表达式所在函数体内所有局部变量的引用，叫默认引用捕获。获取指针和值，可修改值。
#include<iostream>
using namespace std;
int main()
{
int i = 10;
int j = 20;
int k = 30;
auto func = [](int a) {return a; };
cout << "func为：" << func(10) << endl;
auto max = [](int a, int b) {if (a > b) { return a; } else return b; };
cout << endl<< "max为：" << max(4, 44) << endl;
auto test1 = [=]() { cout <<"i为："<< i << endl <<"j为：" << j << endl<< "k为：" << k << endl; };
auto test2 = [=, &i]() { i = 99; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };
auto test3 = [&, i]() { k=j = 999; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };
cout << endl << "test1----------------" << endl;
test1();
cout << endl << "test2----------------" << endl;
test2();
cout << "i的值为：" << i << endl;
cout << endl << "test3----------------" << endl;
test3();
cout << "i的值为：" << i << endl;
return 0;
}
i的值在test2()和test3()中不一样，但是在main函数体内，调用test2()后i的值一直是99，说明了Lambda表达式在预编译阶段完成。
#include<iostream>
using namespace std;
#include<functional>
class Test
{
public:
static int myTest(int n)
{
return n;
}
int operator()(int n)
{
return n;
}
};
int test(int n)
{
return n;
}
void foo(int a,int b, int c)
{
cout << a << b << c << endl << endl;
}
int main()
{
//函数对象包装器
//为函数提供容器（即封装）
//支持四种函数
//1.普通函数
function<int(int)> f1= test;
cout << "f1=" << f1(100) << endl;
auto f2 = test;
cout << "f2=" << f2(200) << endl;;
//2.匿名函数
function<int(int)> f3 = [](int n)->int {return n; };
cout << "f3=" << f3(300) << endl;
function<int(int)> f4 = [](int n) {return n; };
cout << "f4=" << f4(400) << endl;
//3.成员函数
function<int(int)> f5 =Test::myTest;
//auto f5 = &Test::myTest;
Test t1;
cout << "f5=" << f5(500) << endl;
//4.仿函数
function<int(Test*, int)> f6 = &Test::operator();
cout << "f6=" << f6(&t1, 600) << endl;
auto f7=bind(foo, 10, 20, 30);
f7();
auto f8 = bind(foo, 10, placeholders::_1, 30);
f8(20);
auto f9 = bind(foo, placeholders::_2, placeholders::_1, 30);
f9(10,20);
return 0;
}auto f9 = bind(foo, 10, placeholders::_1, 30);
//error! 因为第一个参数还没使用就使用第二个参数了
f9(20);//error!
测试：
unique_ptr:
有且仅有一个，不能拷贝，不能赋值。假设两个引用指向同一个指针，如果一个引用销毁了该指针，那么另一个引用则为空，会导致内存泄露，因此编译器不让unique指针进行赋值或拷贝操作。
unique_ptr<Test> t1 = make_unique<Test>();
unique_ptr<Test> t1(new Test());// 可能会出现异常安全问题
unique_ptr<Test> t2 = t1；//error!
shared_ptr:
该指针可共享，（都为共享指针时）赋值或拷贝一次会增加引用数，当引用数为零时，内存释放。什么情况下，引用减少呢？就是共享指针脱离作用域时减少一次引用数。
shared_ptr<Test> t2 = make_shared<Test>();//进行一次内存分配
shared_ptr<Test> t3 (new Test());//会进行两次内存分配，new了后再拷贝，共两次。
shared_ptr<Test> t4；
t4=t3;//引用数+1。
weak_ptr:
目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造。不会增加共享指针的引用数，也是在作用域内生存，脱离生存期立即死亡。