Lambda表达式、std::function、和std::bind函数

Lambda表达式、std::function、和std::bind函数

Lambda表达式

[capture](parameters) mutable exception->return-type{statement};

1、capture：捕获外部变量列表
2、parameters：参数列表，如果不需要参数可以省略，“（）”可以i一起省略
3、mutable：指示符，有来表示是否可以修改捕获的变量；默认Lambda函数是一个const函数；
4、exception：异常设定
5、return type：返回类型；不需要返回类型时，可以将“->”一起省略；如果函数体重有return语句，则Lambda表达式的返回类型由函数体中return语句的返回类型决定；如果函数体中没有没有return语句 ，则返回类型为void类型；
6、statement：函数体，与普通函数一样；

格式

[capture list] (params list) -> return type {function body};
[capture list] (params list) {function body};
[capture list] {function body};

捕获值列表

Lambda表达式可以捕获所在作用域可访问的值，包括临时变量、类的可访问成员，全局变量，可在函数体中使用这些变量；捕获方式可以是按值捕获，也可以是按引用捕获；

1、[ ]：没有使用任何函数或对象；
2、[=]：Lambda表达式所在函数体内可用的所有变量，包括类的this指针，是怡值传递的凡方式；
3、[&]：与[=]捕获的变量一样，但是以引用的方式捕获；
4、[var]：将某个变量var以值传递的方式捕获；
5、[&var]：将某个变变量var以引用的方式捕获；
6、[=,&var]：除变量var以引用 的方式捕获，其他的以值传递的方式捕获；

#include<iostream>         
using namespace std;       
                           
int main()                 
{                          
    int num = 10;            
    auto val_lambda = [=]{ return num + 1; };
    auto ref_lambda = [&]{ return num + 1; };
    cout<<"val_lambda: "<<val_lambda()<<endl;
    cout<<"ref_lambda: "<<ref_lambda()<<endl;
                           
    num++;                   
    cout<<"val_lambda: "<<val_lambda()<<endl;
    cout<<"ref_lambda: "<<ref_lambda()<<endl;
                           
    return 0;              
}
程序输出结果如下：
 
val_lambda: 11
ref_lambda: 11
val_lambda: 11
ref_lambda: 12

std::function

std::function包含在头文件中，是一个类模板，可以对各种可调用实体进行封装，形成一个新的可调用std::function对象；
可调用实体包括普通函数，Lambda表达式，函数指针以及其他函数对象(仿函数)；

#include <iostream>
#include <functional>

using namespace std;
function<bool(int, int)> fun;

bool compare_com(int a, int b)
{
	return a > b;
}

auto compare_lambda = [](int a, int b) {return a > b; };

class compare_class
{
public:
	bool operator()(int a, int b)
	{
		return a > b;
	}
};

class compare
{
public:
	bool compare_num(int a, int b)
	{
		return a > b;
	}

	static bool compare_static(int a, int b)
	{
		return a > b;
	}
};

int main()
{
    bool result;
    fun = compare_com;
    result = fun(10, 1);
    cout << "普通函数输出, result is " << result << endl;
 
    fun = compare_lambda;
    result = fun(10, 1);
    cout << "lambda表达式输出, result is " << result << endl;
 
    fun = compare_class();
    result = fun(10, 1);
    cout << "仿函数输出, result is " << result << endl;
 
    fun = compare::compare_static;
    result = fun(10, 1);
    cout << "类静态成员函数输出, result is " << result << endl;
 
    //类普通成员函数比较特殊，需要使用bind函数，并且需要实例化对象，成员函数要加取地址符
    compare temp;
    fun = std::bind(&compare::compare_member, temp, std::placeholders::_1, std::placeholders::_2);
    result = fun(10, 1);
    cout << "类普通成员函数输出, result is " << result << endl;

std::bind

std::bind是一个通用函数的适配器，通过接受一个可调用对象来生成一个新的可调用对象，可将可调用对象与其参数一起进行绑定，后使用std::function保存，有两个作用

1、将可调用对象啊和其参数绑定成一个仿函数；
2、只绑定部分参数，减少可调用对象传入的参数

std::function<bool(int) func;
func = std::bind(compare_class, 5, std::placeholders::_1);
cout << "bind函数测试" << func(6) << endl;

bind绑定类成员函数时，第一个参数表示类对象的成员函数的指针，第二个表示对象或对象地址；
std::placeholders::_1是占位符，从小到大确定对应的参数；

https://blog.csdn.net/xiaoyink/article/details/79348806?utm_medium=distribute.pc_relevant_download.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_download.none-task-blog-baidujs-2.nonecase
https://blog.csdn.net/xihuanzhi1854/article/details/89889461?utm_medium=distribute.pc_relevant_download.none-task-blog-BlogCommendFromBaidu-2.nonecase&depth_1-utm_source=distribute.pc_relevant_download.none-task-blog-BlogCommendFromBaidu-2.nonecas