lambda
lambda表达式语法
-
lambda 表达式本质是一个匿名函数对象，可以定义在函数内部，一般用auto或者模板参数定义的对象去接收 lambda 对象
-
格式：[捕捉列表] (参数列表) -> 返回值类型 {函数体}
-
捕捉列表\] ：根据\[\]来判断接下来的代码是不是lambda函数，捕捉列表为空也不能省略
- -> 返回值类型：没有返回值和返回值类型明确的情况下，也可以省略，由编译器对返回类型进行推导
- {函数体}：在函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略
-
-
lambda表达式适用于轻量级的局部小函数，不能递归调用
int main()
{
//一个简单的lambda表达式
auto add1 = [](int x, int y)->int
{
return x + y;
};
cout << add1(1, 2) << endl; //3//1.捕捉为空也不能省略 //2.参数为空可以省略 //3.返回值可以省略，可以通过返回对象自动推导 //4.函数体不能省略 auto func1 = [] //省略参数、返回类型 { cout << "hello ssp" << endl; return 0; }; func1(); //hello ssp int a = 0, b = 1; auto swap1 = [](int& x, int& y) //省略返回类型 { int tmp = x; x = y; y = tmp; }; swap1(a, b); cout << a << ":" << b << endl; //1:0 return 0;}
捕捉列表
-
lambda默认只能用lambda函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉
-
第一种捕捉方式：在捕捉列表中显示的传值捕捉或传引用捕捉，捕捉的多个变量用逗号分割。[x,y,&z]表示x和y值捕捉，z引用捕捉
-
第二种捕捉方式：在捕捉列表中隐式捕捉。在捕捉列表写一个=表示隐式值捕捉，在捕捉列表写一个&表示隐式引用捕捉，这样写的话lambda表达式中用了哪些变量，编译器就会自动捕捉哪些变量，不会全部捕捉
-
第三种捕捉方式：混合使用隐式捕捉和显示捕捉
-
=,\&x\]表示其他变量隐式值捕捉，x引用捕捉
-
-
lambda表达式如果在函数局部域中，捕捉列表可以捕捉lambda位置之前的变量（除了类域，其余都是向上查找），不能捕捉静态变量和全局变量，静态变量和全局变量也不需要捕捉，在lambda表达式中可以直接使用。这也就意味者，lambda表达式如果定义在全局位置，捕捉列表必须为空（一般也不会写到全局）
-
默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉过来的对象不能修改。mutable加到参数列表的后面可以取消其常量属性。也就是说，使用mutable修饰符后，传值捕捉的对象就可以修改了，但是修改的还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略（即使参数为空）
int x = 0;
//定义在全局捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可捕捉的变量
auto func1 =
{
x++;
};int main()
{
//只能用当前lambda局部域和捕捉的对象和全局对象
int a = 0, b = 1, c = 2, d = 3;
auto func1 = [a, &b] //除了类域，都是向上查找
{
//值捕捉的变量不能修改，引用捕捉的变量可以修改
//a++ //错误
b++; //会影响外面的b
int ret = a + b;
return ret;
};
cout << func1() << endl; //2//隐式值捕捉 //用了哪些变量就捕捉哪些变量 auto func2 = [=]() { int ret = a + b + c; return ret; }; cout << func2() << endl; //4 //隐式引用捕捉 //用了哪些变量就捕捉哪些变量 auto func3 = [&] { a++; c++; d++; }; func3(); cout << a << " " << b << " " << c << " " << d << endl; //1 2 3 4 //混合捕捉1 auto func4 = [&, a, b] { //a++; //b++; c++; d++; return a + b + c + d; }; func4(); cout << a << " " << b << " " << c << " " << d << endl; //1 2 4 5 //混合捕捉2 auto func5 = [=, &a, &b] { a++; b++; //c++; //d++; return a + b + c + d; }; func5(); cout << a << " " << b << " " << c << " " << d << endl; //2 3 4 5 //局部的静态和全局变量不能捕捉，也不需要捕捉 static int m = 0; auto func6 = [] { int ret = x + m; return ret; }; //传值捕捉本质是一种拷贝，并且被const修饰了 //mutable相当于去掉const属性，可以修改了 //但是修改不会影响外面被捕捉的值，因为是一种拷贝 auto func7 = [=]()mutable { a++; b++; c++; d++; return a + b + c + d; }; cout << func7() << endl; //18 cout << a << " " << b << " " << c << " " << d << endl; //3 4 5 6 return 0;}
lambda应用
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 } };
//类似这样的场景，我们实现仿函数对象或者函数指针支持不同项的比较
//相对还是比较麻烦的，不写注释也方便理解，那么用lambda就很好用了
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
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._price > g2._price;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate;
});
return 0;
}lambda的原理
- lambda底层是仿函数对象，也就是说我们写了一个lambda之后，编译器会生成一个对应的仿函数的类
- lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体，lambda的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是lambda类构造函数的实参
包装器
- 要==#include <functional>==
function
-
std::function 是一个类模板，也是一个包装器。std::function 的实例对象可以包装存储其他的可调用对象，包括函数指针、仿函数、lambda、blind表达式等，存储的可调用对象成为std::function的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常
-
函数指针、仿函数、lambda等可调用对象的类型不同，std::function的优势就是同一类型，对他们进行包装。
#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:
Plus(int n=10)
:_n(n)
{ }static int plusi(int a, int b) { return a + b; } double plusd(double a, double b) { return (a + b) * _n; }private:
int _n;
};int main()
{
//包装各种可调用对象,需要参数类型匹配
function<int(int, int)> f1 = f; //第一个int是返回值类型，(int.int)为参数列表
function<int(int, int)> f2 = Functor();
function<int(int, int)> f3 = [](int a, int b) {return a + b; };cout << f1(1, 1) << endl; cout << f2(1, 1) << endl; cout << f3(1, 1) << endl; //包装静态成员函数 //成员函数要指定类域并且前面加&才能获取地址 //&静态的可加可不加，非静态的必须加& function<int(int, int)> f4 = &Plus::plusi; cout << f4(1, 1) << endl; //包装普通成员函数 //普通成员函数还有一个隐含的this指针参数， //所以绑定时要传对象或者对象的引用或指针过去 function<double(Plus*, double, double)> f5 = &Plus::plusd; Plus pd; //是用传入的对象去调用函数 cout << f5(&pd, 1.1, 1.1) << endl; function<double(Plus, double, double)> f6 = &Plus::plusd; cout << f6(pd, 1.1, 1.1) << endl; function<double(Plus&&, double, double)> f7 = &Plus::plusd; cout << f7(move(pd), 1.1, 1.1) << endl; //用右值引用 cout << f7(Plus(), 1.1, 1.1) << endl; //用匿名对象 return 0;}
bind
-
bind 是一个函数模板，他也是一个可调用对象的包装器，对接受的fn可调用对象进行处理后返回一个可调用对象。
-
bind可以用来调整参数个数和参数顺序，它也包含在<functional>头文件中
-
格式：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为第二个参数，以此类推。_1/_2/_3...这些占位符放到placeholders的一个命名空间
class Plus
{
public:
Plus(int n=10)
:_n(n)
{ }static int plusi(int a, int b) { return a + b; } double plusd(double a, double b) { return (a + b) * _n; }private:
int _n;
};int main()
{
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl; //50//bind本质是返回的一个仿函数对象 //调整参数顺序（不常用） //_1表示第一个实参 //_2表示第二个实参 //...... auto sub2 = bind(Sub, _2, _1); cout << sub2(10, 5) << endl; //-50 //调整参数个数(常用) auto sub3 = bind(Sub, 100, _1); //把a固定为100 cout << sub3(3) << endl; //970 auto sub4 = bind(Sub, _1, 100); //把b固定为100 cout << sub4(3) << endl; //-970 //分别绑死第123个参数 auto sub5 = bind(SubX, 100, _1, _2); //100-_1-_2 cout << sub5(5, 1) << endl; auto sub6 = bind(SubX, _1, 100, _2); //_1-100-_2 cout << sub6(5, 1) << endl; auto sub7 = bind(SubX, _1, _2, 100); //_1-_2-100 cout << sub7(5, 1) << endl; //成员函数对象进行绑死，就不需要每次传递了 function<double(Plus&&, double, double)> f6 = &Plus::plusd; Plus pd; cout << f6(move(pd), 1.1, 1.1) << endl; cout << f6(Plus(), 1.1, 1.1) << endl; //bind一般用于绑死一些固定参数 function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2); cout << f7(1.1, 1.1) << endl; return 0;}