做家具有那个网站,公司品牌推广方案范文,深圳手机网站制作公司,wordpress 会员付费C11中 1.lambda表达式2.可变参数模板3.包装器 1.lambda表达式
在前面我们学习过仿函数。仿函数的作用到底是干什么的呢#xff1f; 它为了抛弃函数指针#xff01;
主要是因为函数指针太难学了 就比如下面这个#xff0c;看着也挺难受的。 它的参数是一个函数指针#x… C11中 1.lambda表达式2.可变参数模板3.包装器 1.lambda表达式
在前面我们学习过仿函数。仿函数的作用到底是干什么的呢 它为了抛弃函数指针
主要是因为函数指针太难学了 就比如下面这个看着也挺难受的。 它的参数是一个函数指针返回值也是一个函数指针
就如在C98中如果想要对一个数据集合中的元素进行排序可以使用std::sort方法。也可以提供一个仿函数用来控制排序方式非常舒服
#include algorithm
#include functionalint 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]), greaterint());return 0;
}注意 模板传仿函数传仿函数类型 函数传仿函数传仿函数对象
仿函数默认小于升序可以自己写一个大于降序的 【内部是cmp(v[i1],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()
{vectorGoods 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()
{vectorGoods 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函数定义中参数列表和返回值类型都是可选部分而捕捉列表和函数体可以为空。因此C11中最简单的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 xb}和其他就不是同一个域 那怎么办呢 不要忘了这里的有一个捕捉列表
[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;
}默认捕捉是一种传值拷贝捕捉里面的ab和外面的ab不是同一个交换不起作用并且默认捕捉带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表达式的方便不对线程接口具体结束下篇文章具体说。 下面是两个线程虽然传递了同一个参数但是各跑各的是一种并行方式。
#includethreadvoid 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()
{vectorthread 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等的KeyofTKeyofValue等模板参数就只能传递类型过去而lambda是一个匿名函数对象对于函数模板要传对象来说用着更好一些。
lambda表达式底层 遇到lambda编译器底层实际上就把它转成一个类。底层还是调用的operator()仿函数。
2.可变参数模板
可变参数模板对应的是C语言的可变参数
printf就是我们经常用的可变参数 …就是代表的可变参数
C11的新特性可变参数模板能够让你创建可以接受可变参数的函数模板和类模板相比C98/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。同时还用到了C11的另外一个特性——初始化列表通过初始化列表来初始化一个变长数组, {(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()
{shestd::listint 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::pairint, 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()
{pairint, bit::string kv(20, sort);std::list std::pairint, 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()
{pairint, bit::string kv(20, sort);std::list std::pairint, 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函数模板会被实例化多少份呢
templateclass 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 functionRet(Args...);模板参数说明
Ret: 被调用函数的返回类型
Args…被调用函数的形参先来用一下
#includefunctionalint 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()
{//()外面是被调函数返回类型,()里面是对调用函数的参数//包装函数指针functionint(int, int) f1;f1 f;functionint(int, int) f2(f);//像函数一样调用,其实它的底层还是一个仿函数cout f1(1, 1) endl;cout f2(1, 1) endl;//包装函数对象f1 Functor();Functor ft;functionint(int, int) f3(ft);//functionint(int, int) f3(Functor()); // 不能这样写识别报错functionint(int, int) f3 Functor();// 函数对象cout f1(1, 2) endl;cout f3(1, 3) endl;//包装lambda表达式functionint(int, int) f4 [](const int a, const int b) {return a b; }; // lambdacout f4(1, 3) endl;//包装成员函数//这里有些细节要注意//类成员函数必要前面要用类域进行限制因为成员函数都在类域里面//1.包装类的静态成员函数//对于静态成员函数类域前面可加可不加但是建议加上functionint(int, int) f5 Plus::plusi; // 类静态成员函数指针functionint(int, int) f5 Plus::plusi; // 类静态成员函数指针cout f5(1, 2) endl;//2.包装类的非静态成员函数//这里细节较多//如果是成员函数指针还需要多一个参数因为对于成员函数指针调用的时候它多了一个this指针但是不要写Plus*因为this指针不允许显示传递//并且类域前面必须要加functionint(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;
functiondouble(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(vectorstring tokens) {stackint _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(leftright);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(vectorstring tokens) {stackint _st;mapstring,functionint(int,int) opFuncMap {{,[](int x,int y)-int{return xy;}},{-,[](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();}
};现在了解了包装器我们就可以把最初的如何实例化一份的问题解决一下
templateclass 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(functiondouble(double)(f), 11.11) endl;// 函数对象Functor ft;cout useF(functiondouble(double)(ft), 11.11) endl;// lamber表达式cout useF(functiondouble(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 的第一二个参数指定functionint(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 的第一二个参数指定functionint(int, int) func1 bind(Plus, placeholders::_1, placeholders::_2);functionint(int, int) func2 bind(SubFunc, placeholders::_1, placeholders::_2);//这个是正常的_1代表SubFunc第一个参数a_2代表SubFunc第二个参数bcout func2(1, 2) endl;// 调整参数的顺序functionint(int, int) func3 bind(SubFunc, placeholders::_2, placeholders::_1);//无论顺序怎么换_1永远代表SubFunc第一个参数a_2永远代表SubFunc第二个参数b//这里是2传给a1传给bcout 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()
{//绑定固定参数//类成员函数多了一个参数每次调用都需要在前面传一个对象然后才能调用functionint(Sub, int, int) func4 Sub::sub;cout func4(Sub(), 10, 20) endl;//那如果不想传第一个参数就想和其他一样的调用就可以绑定固定参数//把第一个参数给绑定现在只需要显示传传两个参数就行了functionint(int, int) func5 bind(Sub::sub, Sub(), placeholders::_1, placeholders::_2);cout func5(10, 20) endl;return 0;
}本来类成员函数应该传三个参数但是有一个参数基本是确定的就可以绑定固定的参数相当于减少参数的个数就相当于第一个参数已经传了。
function是想对各种可调用对象函数指针、函数对象lambda进行适配包装给一个统一的类型。
bind是对可调用的对象的参数进行绑定然后调整绑死。
