C++11中
- 1.lambda表达式
- 2.可变参数模板
- 3.包装器
1.lambda表达式
在前面我们学习过仿函数。仿函数的作用到底是干什么的呢？
它为了抛弃函数指针！
主要是因为函数指针太难学了
就比如下面这个，看着也挺难受的。
它的参数是一个函数指针，返回值也是一个函数指针！
就如在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;
}
注意：
模板传仿函数，传仿函数类型
函数传仿函数，传仿函数对象
仿函数默认小于升序，可以自己写一个大于降序的 【内部是cmp(v[i+1],v[i])比较】
就比如把下面的对象如果按照评价，价格排序，要是重载()进行排序就需要写两个仿函数。如果在按照别的排序还需要重新再写一个对应的仿函数，这样写太麻烦了。而且仿函数名字取不好，就更麻烦了！
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());
return 0;
}
但如果是下面这样写个lambda表达式，就很清晰
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());
//sort传一个可调用的匿名对象
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;//价格升序
});
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr) {return gl._price > gl._price; });//价格降序
return 0;
}
lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式各部分说明
-
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
-
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
-
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
-
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
-
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
[capture-list] : 捕捉列表 必须要写用来判断是否是一个lambda表达式
(parameters)：参数列表 有参数就写没参数就不写
mutable 是一个修饰符一般都不需要
->returntype：返回值类型 一般都不写，编译器自动推导
{statement}：函数体 必须要写
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
lambda表达式实际是一个的可以调用的匿名函数对象!
int main()
{
//写一个进行int对象比较的lambda
//[](int x, int y)->bool {return x > y; };//指定返回值类型
[](int x, int y) {return x > y; };
return 0;
}
没有名字写完怎么调用呢？
int main()
{
//写一个进行int对象比较的lambda
//auto compare = [](int x, int y)->bool {return x > y; };//指定返回值类型
auto compare = [](int x, int y) {return x > y; };
cout << compare(1, 2) << endl;//可以像函数一样调用
return 0;
}
lambda表达式写不出它的类型，只能用auto去识别它的类型，如果不用auto，就直接传过去。（后面看底层就知道）
这里就相当于传个匿名对象过去，用着挺香的。
看下面一段代码
int main()
{
int a = 0, b = 1;
auto add1 = [](int x, int y) { return x + y; };
cout << add1(a, b) << endl;
//这样对吗? 能不能直接用b?
auto add2 = [](int x) {return x + b; };
cout << add2(a,b) << endl;
return 0;
}
显然是用不了的，{return x+b}和其他就不是同一个域 那怎么办呢？
不要忘了，这里的有一个捕捉列表
[capture-list] : 捕捉列表，捕捉外面的对象，想要谁就把谁抓过来！
int main()
{
int a = 0, b = 1;
auto add1 = [](int x, int y) { return x + y; };
cout << add1(a, b) << endl;
//auto add2 = [](int x) {return x + b; };
//cout << add2(a,b) << endl;
auto add2 = [b](int x) {return x + b; };
cout << add2(a) << endl;//这样也可以少传一个参数
return 0;
}
抓多个
int main()
{
int a = 0, b = 1;
auto add1 = [](int x, int y) { return x + y; };
cout << add1(a, b) << endl;
auto add2 = [b](int x) {return x + b; };
cout << add2(a) << endl;
//多捕捉
auto swap = [a, b] {
int tmp = a;
a = b;
b = tmp;
};
return 0;
}
默认捕捉是一种传值拷贝捕捉，里面的a，b和外面的a，b不是同一个交换不起作用，并且默认捕捉带const属性 还不让你修改！
如果真想修改就取消常性。
int main()
{
//多捕捉
auto swap = [a, b]()mutable
{
int tmp = a;
a = b;
b = tmp;
};
swap();
cout << a << ":" << b << endl;
return 0;
}
可以看到虽然用来mutable，但是没有用。a和b根本没有交换。里面的a和b是外面的拷贝，mutable只是让这个拷贝的对象可以改。
真正里面改了外面也会跟着改，就加个&引用
int main()
{
int a = 0, b = 1;
//以引用方式捕捉
auto swap = [&a, &b]()
{
int tmp = a;
a = b;
b = tmp;
};
swap();
cout << a << ":" << b << endl;
return 0;
}
接下来就探讨捕捉的方式
1.[a,b] 传值捕捉
2.[&a,&b] 传引用捕捉
3.[=] 传值捕捉方式父作用域中所有变量（包括this指针）
int main()
{
int a = 0, b = 1;
auto swap = [=]()
{//这对括号外面的一层就是父作用域
int tmp = a;
a = b;
b = tmp;
};
swap();
cout << a << ":" << b << endl;
return 0;
}
4.[&] 传引用捕捉方式父作用域中所有变量（包括this指针）
int main()
{
int a = 0, b = 1;
auto swap = [&]()
{//这对括号外面的一层就是父作用域
int tmp = a;
a = b;
b = tmp;
};
swap();
cout << a << ":" << b << endl;
return 0;
}
5.混合捕捉
[a,&b]
[=,&b] 除了b传引用捕捉，其他所有变量都是传值捕捉
[&,b] 除了b传值捕捉，其他所有变量都是传引用捕捉
注意 = & 只能捕捉父作用域上面的。
int main()
{
int x = 0, y = 1;
auto func2 = [=, &y]()
{
cout << m << endl;
};
int m = 0;
return 0;
}
并且只能这样捕捉[&x,y]，而不能这样[&x,y++]。因为只是捕捉，并不是传参。
在linux的时候我们学过了线程，现在先用一下C++提供的线程接口
这里主要是为了看到用lambda表达式的方便，不对线程接口具体结束，下篇文章具体说。
下面是两个线程，虽然传递了同一个参数，但是各跑各的，是一种并行方式。
#include<thread>
void print1(int x)
{
for (; x < 100; ++x)
{
cout << "thread1:" << x << endl;
}
}
void print2(int y)
{
for (; y < 100; ++y)
{
cout << "thread2:" << y << endl;
}
}
int main()
{
int i = 0;
thread t1(print1,i);
thread t2(print2,i);
t1.join();
t2.join();
return 0;
}
但是现在有一个需求，希望两个线程同时对i变量++，总共加100次怎么做呢？
当然可以传引用传参
void print1(int& x)
{
for (; x < 100; ++x)
{
cout << "thread1:" << x << endl;
}
}
void print2(int& y)
{
for (; y < 100; ++y)
{
cout << "thread2:" << y << endl;
}
}
int main()
{
int i = 0;
thread t1(print1,ref(i));//注意这里也要改一下，不然传不过去
thread t2(print2,ref(i));
t1.join();
t2.join();
return 0;
}
也可以把i变成全局变量，当前这两个都涉及线程安全的问题，后面再说。
上面都是常规写法，下面我们见见使用lambda表达式这种方法
int main()
{
int i = 0;
//thread t1(print1,ref(i));
//thread t2(print2,ref(i));
thread t1([&i]()
{
for (; i < 100; ++i)
{
cout << "thread1:" << i << endl;
}
});
thread t2([&i]()
{
for (; i < 100; ++i)
{
cout << "thread2:" << i << endl;
}
});
t1.join();
t2.join();
return 0;
}
为什么可以这样传呢，因为这是一个万能引用，既可以传左值也可以传右值，只要是一个可调用对象，可调用对象有函数指针、仿函数、还有lambda。
lambda在这里用起来挺香的！
如果在进一步要求，让n个线程实现这个加呢？
注意线程只有移动构造和移动赋值
int main()
{
vector<thread> Vthreads;
int n;
cin >> n;
Vthreads.resize(n);//调用创建线程无参构造
int i = 0;
int x = 0;
for (auto& t : Vthreads)
{
//移动赋值
t = thread([&i, x]
{
while (i < 1000)
{
cout << "thread" << x << "->" << i << endl;
++i;
}
});
x++;
}
for (auto& t : Vthreads)
{
t.join();
}
return 0;
}
虽然lambda表达式用着很舒服，但是不能完全代替仿函数，因为就像以前模拟实现map和set等的KeyofT，KeyofValue等模板参数就只能传递类型过去，而lambda是一个匿名函数对象对于函数模板要传对象来说用着更好一些。
lambda表达式底层
遇到lambda，编译器底层实际上就把它转成一个类。底层还是调用的operator()仿函数。
2.可变参数模板
可变参数模板对应的是C语言的可变参数
printf就是我们经常用的可变参数
…就是代表的可变参数
C++11的新特性可变参数模板能够让你创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变参数模版无疑是一个巨大的改进。然而由于可变参数模版比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止。
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
thread就用了可变参数包，还加上万能引用既可以接收左值也可以接收右值
emplace系列也用的这个
·
以前就是传固定的对象做参数。现在用这个可变参数包就可以传0-N个对象做参数。
如何传这个参数呢？
template <class ...Args>
void ShowList(Args... args)
{
//参数包中有几个参数
cout << sizeof...(args) << endl;
}
int main()
{
//想传什么类型就传什么类型,想传几个就传几个
ShowList(1);
ShowList(1, 1.1);
ShowList(1, 1.1,string("xxxxxx"));
return 0;
}
如何打印出传的参数呢？这里有两种方式！
递归函数方式展开参数包
void ShowList()
{
cout << endl;
}
//args参数包可以接收0-N个参数
template <class T,class ...Args>
void ShowList(T val, Args... args)
{
cout << val << " ";
ShowList(args...);
}
int main()
{
//想传什么类型就传什么类型,想传几个就传几个
ShowList(1);
ShowList(1, 1.1);
ShowList(1, 1.1,string("xxxxxx"));
return 0;
}
第一个参数传给val，剩下的传一个参数包给args。
第一个ShowList第一个参数传给val，剩下没有参数了就去调用上面没有参数的ShowList然后就结束了。
第二个ShowList第一个参数传给val，剩下一个参数传给参数包，就似在递归调用一次有参数的ShowList，然后第一个参数在给val，剩下没有参数在调用一次无参的ShowList就结束了。
第三个ShowList也和上面的一样。
逗号表达式展开参数包
这种展开参数包的方式，不需要通过递归终止函数，是直接在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>
int PrintArg(T t)
{
cout << t << " ";
return 0;
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 1.1);
ShowList(1, 1.1, string("xxxxxx"));
return 0;
}
这是一个逗号表达式，取得是最后一个值，也就是0去初始化这个arr数组，这个数组大小取决于列表给了几个值。
…代表参数包，把这个参数表展开，里面有几个参数就有几个值，数组就初始化多大。
参数包里面得内容依次传给t。
但是这样得写法加了逗号表达式加深了理解成本。
我们可以不用逗号表达式，就像下面这种写法
template <class T>
int PrintArg(T t)
{
cout << t << " ";
return 0;
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { PrintArg(args)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 1.1);
ShowList(1, 1.1, string("xxxxxx"));
return 0;
}
展开参数包去初始化这个数组，想当于就是把它全展开
STL容器中的empalce相关接口函数：
所有容器除了提供左值右值版本的插入，还会提供emplace系列版本的插入。
而这种就已经写死了，只能传一个参数！
emplace系列的插入可以传0-N个参数
相比于其他插入emplace系列的插入也确实更高效一点。下面就具体看看高效在哪里！
如果是内置类型，只有一个参数的这种，没有任何区别
int main()
{she
std::list<int> list1;
list1.push_back(1);
list1.emplace_back(2);
//甚至emplace_back可以不传参数，可以认为传了一个int匿名对象
list1.emplace_back();
for (auto e : list1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
并且不能传多个，只能传0个或者多个
如果是一个自定义类型，有多个参数
int main()
{
std::list< std::pair<int, char> > mylist;
//可以还像以前那样构造一个pair对象然后再传
mylist.push_back(make_pair(1, 'a')); // 构造+拷贝构造
//mylist.push_back(1, 'a');//这样是不能传的
//可以认为是pair的参数包，拿着后不着急一直往下走，等到构造piar对象到链表结点的时候直接构造piar对象
mylist.emplace_back(1, 'a'); // 直接构造
return 0;
}
接下来我们对比emplace系列插入的其他插入的效率
int main()
{
pair<int, bit::string> kv(20, "sort");
std::list< std::pair<int, bit::string> > mylist;
mylist.push_back(kv); // 左值
mylist.push_back(make_pair(30, "sort")); // 右值
mylist.push_back({ 40, "sort" }); // 列表初始化生成一个piar的临时对象 右值
return 0;
}
左值是构造+深拷贝，右值是构造+移动构造，所以传参尽量给右值
现在看emplace插入，然后对比一下
int main()
{
pair<int, bit::string> kv(20, "sort");
std::list< std::pair<int, bit::string> > mylist;
mylist.emplace_back(kv); // 左值
mylist.emplace_back(make_pair(20, "sort")); // 右值
mylist.emplace_back(10, "sort"); // 构造pair参数包
cout << endl;
mylist.push_back(kv); // 左值
mylist.push_back(make_pair(30, "sort")); // 右值
mylist.push_back({ 40, "sort" }); // 列表初始化生成一个piar的临时对象 右值
return 0;
}
最直观的感觉就是少调用了一些参数。
第一个传左值还是构造+深拷贝
第三个是传一个构造pair的参数包，一直往下传，传到最后要构造节点的时候用piar的参数包直接去构造一个pair
第二个传一个匿名对象是个右值，本来是构造+移动构造，但是编译器直接优化到最后直接构造一个pair，可以认为emplace把匿名对象右值当成参数包。
总结：emplace系列对右值和参数包少拷贝一次直接构造，因此尽量传右值和参数包，对于左值emplace不敢动只能是构造+深拷贝。
对于把构造+移动构造优化成构造感觉效率提高并不明显，因为移动构造就是交换一下，但是对于没有实现移动构造，emplace的效率就提升很明显了。
3.包装器
function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
在C++中目前可调用对象或者可调用类型我们已经学了很多有：
函数指针
仿函数/函数对象
lambda
还有马上就学的包装器
包装器并不是自己定义一个可调用的对象，而是对前三种对象进行包装，包装成一个新的可调用的对象。它包装之后把类型进行统一然后调用！
就比如下面这个func的调用，你觉得它是什么呢？
ret = func(x);
int main()
{
return 0;
}
不好说，有可能是函数指针，仿函数，或者lambda。
这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么这样说呢，看下面这个调用useF，第一个参数接收可调用对象，最后会去调用可调用对象。那这个useF函数模板会被实例化多少份呢？
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;
// lambda表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
}
由于传给f的对象不一样，可以看到上面的函数模板会被实例化出三份
假设要求只实例化出一份怎么做呢？
包装器可以很好的解决上面的问题。
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
先来用一下
#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()
{
//()外面是被调函数返回类型,()里面是对调用函数的参数
//包装函数指针
function<int(int, int)> f1;
f1 = f;
function<int(int, int)> f2(f);
//像函数一样调用,其实它的底层还是一个仿函数
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
//包装函数对象
f1 = Functor();
Functor ft;
function<int(int, int)> f3(ft);
//function<int(int, int)> f3(Functor()); // 不能这样写，识别报错
function<int(int, int)> f3 = Functor();// 函数对象
cout << f1(1, 2) << endl;
cout << f3(1, 3) << endl;
//包装lambda表达式
function<int(int, int)> f4 = [](const int a, const int b) {return a + b; }; // lambda
cout << f4(1, 3) << endl;
//包装成员函数
//这里有些细节要注意
//类成员函数必要前面要用类域进行限制，因为成员函数都在类域里面
//1.包装类的静态成员函数
//对于静态成员函数类域前面&可加可不加，但是建议加上
function<int(int, int)> f5 = &Plus::plusi; // 类静态成员函数指针
function<int(int, int)> f5 = Plus::plusi; // 类静态成员函数指针
cout << f5(1, 2) << endl;
//2.包装类的非静态成员函数
//这里细节较多
//如果是成员函数指针还需要多一个参数，因为对于成员函数指针调用的时候它多了一个this指针，但是不要写Plus*，因为this指针不允许显示传递
//并且类域前面必须要加&
function<int(Plus, int, int)> f6 = &Plus::plusd; // 类成员函数指针
//并且包装之后进行调用，要传一个对象过去
//成员函数的调用必须要用对象来调用，这里是相当于匿名对象，然后调用类里面plusd函数
cout << f6(Plus(), 1, 2) << endl;
//或者定义出一个对象，然后调用
Plus plus;
cout << f6(plus, 1, 2) << endl;
return 0;
}
包装之后，都统一一样的用法。而且用的还是自己本身！虽然类成员函数不一样但是有办法还和其他一样调用。
Plus plus;
function<double(double, double)> f7 = [&plus](double x, double y)->double {return plus.plusd(x, y); };
cout << f7(1, 2) << endl;
包装器本质是对各种可调用对象进行类型统一。
有了这样的东西，比如建立符号和函数之前的响应就很方便了！
150. 逆波兰表达式求值
把后缀转成中缀，如果是操作数就入栈，如果是操作符就取栈顶两个元素进行运算，然后再压进栈
这是以前的玩法
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> _st;
for(auto& str : tokens)
{
if(str == "+" || str == "-" || str == "*" || str == "/")
{
int right=_st.top();
_st.pop();
int left=_st.top();
_st.pop();
switch(str[0])
{
case '+':
_st.push(left+right);
break;
case '-':
_st.push(left-right);
break;
case '*':
_st.push(left*right);
break;
case '/':
_st.push(left/right);
break;
default:
break;
}
}
else
{
//字符串转为int,stoi函数
_st.push(stoi(str));
}
}
return _st.top();
}
};
这里换成包装器的玩法，可以考虑建立命令和动作的映射！
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> _st;
map<string,function<int(int,int)>> opFuncMap =
{
{"+",[](int x,int y)->int{return x+y;}},
{"-",[](int x,int y)->int{return x-y;}},
{"*",[](int x,int y)->int{return x*y;}},
{"/",[](int x,int y)->int{return x/y;}},
//这里还可以添加%其他东西，还是很好用的
};
for(auto& str : tokens)
{
if(opFuncMap.count(str) == 0)
{
_st.push(stoi(str));
}
else
{
int right=_st.top();
_st.pop();
int left=_st.top();
_st.pop();
_st.push(opFuncMap[str](left,right));
}
}
return _st.top();
}
};
现在了解了包装器，我们就可以把最初的如何实例化一份的问题解决一下
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(function<double(double)>(f), 11.11) << endl;
// 函数对象
Functor ft;
cout << useF(function<double(double)>(ft), 11.11) << endl;
// lamber表达式
cout << useF(function<double(double)>([](double d)->double { return d / 4; }), 11.11) << endl;
return 0;
}
包装一下，形成统一的东西，就实例化出一份
bind绑定
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（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可以和function在一起用
int Plus(int a, int b)
{
return a + b;
}
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function<int(int, int)> func1 = bind(Plus, placeholders::_1, placeholders::_2);
cout << func1(1, 2) << endl;
return 0;
}
bind，第一个参数传的是可调用对象
placeholders是一个命名空间，里面定义了很多_1,_2,_3等等，这些东西是一个占位对象。绑定后如果需要自己传参数，_1代表要传的第一个参数，_2代表要传的第二个参数
目前这个绑定啥作用都没起
下面看起一点作用的。
调整参数顺序
int Plus(int a, int b)
{
return a + b;
}
int SubFunc(int a, int b)
{
return a - b;
}
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function<int(int, int)> func1 = bind(Plus, placeholders::_1, placeholders::_2);
function<int(int, int)> func2 = bind(SubFunc, placeholders::_1, placeholders::_2);
//这个是正常的，_1代表SubFunc第一个参数a，_2代表SubFunc第二个参数b
cout << func2(1, 2) << endl;
// 调整参数的顺序
function<int(int, int)> func3 = bind(SubFunc, placeholders::_2, placeholders::_1);
//无论顺序怎么换，_1永远代表SubFunc第一个参数a，_2永远代表SubFunc第二个参数b
//这里是2传给a，1传给b
cout << func3(1, 2) << endl;
return 0;
}
绑定固定参数
class Sub
{
public:
int sub(int a, int b)
{
return a - b * x;
}
private:
int x = 20;
};
int main()
{
//绑定固定参数
//类成员函数多了一个参数，每次调用都需要在前面传一个对象然后才能调用
function<int(Sub, int, int)> func4 = &Sub::sub;
cout << func4(Sub(), 10, 20) << endl;
//那如果不想传第一个参数，就想和其他一样的调用，就可以绑定固定参数
//把第一个参数给绑定，现在只需要显示传传两个参数就行了
function<int(int, int)> func5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
cout << func5(10, 20) << endl;
return 0;
}
本来类成员函数应该传三个参数，但是有一个参数基本是确定的，就可以绑定固定的参数，相当于减少参数的个数，就相当于第一个参数已经传了。
function是想对各种可调用对象函数指针、函数对象，lambda进行适配包装给一个统一的类型。
bind是对可调用的对象的参数进行绑定，然后调整，绑死。
