先提一下lambda
lambda表达式是c++11的新特性,匿名函数对象
形式如下:
cpp
[ capture ] ( params ) opt -> ret { body; };
capture:捕获列表
params:参数列表
opt:函数选项
ret:返回值类型
body:函数体
cpp
//这种写法指定返回值int 是尾置类型推导的写法,当我们在函数执行前不知道返回值
//是什么类型时可以用这种方式指定返回值
auto f = [](int a) -> int {return a + 1;};
cout << f(3) << endl;
//auto f(int) ->bool { return true;}
//== bool f(int) {return true;}
[]:不捕获任何外部变量;
[&]:以引用方式捕获所有外部变量;
[=]:以值方式捕获所有外部变量;
[var1, var2, ...]:指定捕获特定的外部变量;
[&, var1, var2, ...]:以引用方式捕获所有外部变量,并指定捕获特定的外部变量;
[=, &var1, &var2, ...]:以值方式捕获所有外部变量,并以引用方式捕获特定的外部变量。
返回值有时可以省略,可以自动推导
cpp
auto f1 = [](int a, int b) { return a < b; };
cout << f1(1,2);
lambda原理是创建了一个匿名类,并重载了函数调用运算符(),相当于仿函数,实现了一个operator()方法
cpp
auto print = []{cout << "Hello World!" << endl; };
相当于
class print_class
{
public:
void operator()(void) const
{
cout << "Hello World!" << endl;
}
};
auto print = print_class(); //此时print是一个函数对象,或者说仿函数
c++11使用std::function描述C++中所有可调用实体,它是可调用对象的包装器
cpp
#include<functional>
// 声明一个返回值为int,参数为两个int的可调用对象类型
std::function <int(int, int)> Func;
// 普通函数
int add(int a, int b) { return a + b; }
// lambda表达式
auto mod = [](int a, int b){ return a % b; };
// 函数对象类
struct divide{
int operator()(int denominator, int divisor){
return denominator/divisor;
}
};
//类成员函数
class Work
{
public:
int func(int a ,int b)
{
return a*b;
}
}
int main()
{
Func a = add;
a(2,3);
Func b = mod;
Func c = divide;
Work w; // 成员函数 哪个类对象的 参数占位符1 占位2
Func d = bind(&Work::func, &w, placeholders::_1 , placeholders::_2);
d(3,4);
Func e = bind(&Work::func,&w,3,4); //bind出来应该是function<int()>类型,不需要参数了
e(10,20); //结果还是3*4
//e(); 由于Func是std::function<int(int, int)> 所以必须有两个int参数
auto f = bind(&Work::func,&w,3,4);
f(); //这样就可以 结果也是3*4
}
在其中用到bind函数,bind函数可以对已有函数进行封装,主要应用场景是需要接收一个函数作为参数,但已有的格式不符。 bind返回一个function
bind将参数和函数绑定,变成无参函数
bind将类成员函数和类对象绑定,一般想要传入类成员函数作为参数都用这个办法
如果返回值不符,可以用lambda表达式调用函数,忽略返回值以及添加返回值
参数格式不对或者需要增加也可以用lambda