深入理解C++ Lambda表达式：语法、用法与原理及其包装器的使用

lambda表达式
- C++98中的一个例子
- lambda表达式语法
- - lambda表达式各部分说明
  - 捕获列表说明
- 函数对象与lambda表达式
包装器
- function包装器
bind

🌏个人博客主页：个人主页

在这里插入图片描述

本文深入介绍了C++中的Lambda表达式的语法、用法、捕获列表以及其底层原理，强调了其作为函数对象的功能。还探讨了标准库中std::function包装器和std::bind函数的应用，通过它们可以灵活地封装、绑定和简化可调用对象的处理，提升代码的简洁性和可读性。

lambda表达式

C++98中的一个例子

在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;
}

如果待排序元素为自定义类型，需要用户自己定义排序时的比较规则：

struct Goods
{
	string _name; //名字
	double _price;//价格
	int _ecaluate;//评价
	//...

	Goods(const char* str,double price,int evaulate)
		:_name(str)
		,_price(price)
		,_ecaluate(evaulate)
	{}
};

如果我们用运算符重载的方法控制比较逻辑，只能控制一种比较方法，但是如果我们希望希望按照价格，或者评价，名字来排序就没办法实现，所以我们可以通过仿函数来完成。

例如我们如果希望按照价格比较，就提供对应的仿函数：

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(), ComparePriceGreater());
	sort(v.begin(), v.end(), ComparePriceLess());
	
	return 0;
}

但是这里还是有的不方便，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

lambda表达式语法

lambda表达式书写格式：

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

lambda表达式各部分说明

[capture-list] (不能省略): 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[ ]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同( )一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}（不可省略）：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[ ] { }; 该lambda函数不能做任何事情。

如果我们要用lamba表达式写一个两个变量相加的函数，可以这么写。

[](int x, int y)->int {return x + y; };

这个表达式就是一个lamba对象，可以像函数一样直接调用，但是对这个lamba表达式直接调用不太方便，我们通常都是赋值给一个lamba对象，这个对象的类型可以使用auto进行推导。

int main()
{
	auto add1 = [](int x, int y)->int {return x + y; };
	cout << add1(1, 2) << endl;
}

auto add1 = [ ](int x, int y) -> int { return x + y; }; 这行代码会先生成一个 lambda 对象，并将其赋值给 add1。

int main()
{
	auto add1 = [](int x, int y)->int {return x + y; };
	cout << add1(1, 2) << endl;

	auto func1 = []
	{
		//返回值可自动推导类型,所以可以省略
		//无参数可以省略
		cout << "hello world" << endl;

		return 0;
	};

	func1();

	return 0;
}

如果我们不想用仿函数，来完成比较逻辑，就可以这样写：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };

	// 价格升序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
		{
			return g1._price < g2._price;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
		{
			return g1._price > g2._price;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
		{
			return g1._evaluate < g2._evaluate;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
		{
			return g1._evaluate > g2._evaluate;
		});


	return 0;
}

捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

注意：

父作用域指包含lambda函数的语句块
语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
- [=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。
- [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。
捕捉列表不允许变量重复传递，否则就会导致编译错误。
- [=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。
在块作用域以外的lambda函数捕捉列表必须为空。
在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错，但是可以使用全局域的。
lambda表达式之间不能相互赋值，即使看起来类型相同，因为编译器生成的类名不同。

int x = 0;

int main()
{
	// 只能用当前lambda局部域和捕捉的对象和全局对象

	int a = 0, b = 1, c = 2, d = 3;
	// 所有值传值捕捉
	auto func1 = [=]
	{
		int ret = a + b + c + d + x;
		return ret;
	};
	
	// 所有值传引用捕捉
	auto func2 = [&]
	{
		a++;
		b++;
		c++;
		d++;
		int ret = a + b + c + d;
		return ret;
	};

	// 混合捕捉
	auto func3 = [&a, b]
	{
		a++;
		// b++;
		int ret = a + b;
		return ret;
	};

	// 混合捕捉
	// 所有值以引用方式捕捉，d用传值捕捉
	auto func4 = [&, d]
	{
		a++;
		b++;
		c++;
		//d++;

		int ret = a + b + c + d;
	};
	
	// 混合捕捉
	// 所有值以传值方式捕捉，d用传引用捕捉
	auto func5 = [=, &d]()
	{
		//a++;
		//b++;
		//c++;
		d++;
		int ret = a + b + c + d;
	};

	return 0;
}

因为捕获列表只能捕捉父作用域的对象，因为，成员函数默认传的是this指针，所在，这里应该捕捉的应该this指针。

class AA
{
public:
	void func()
	{
		//auto f1 = [this]
		auto f1 = [=]
		{
			cout << _a1 << endl;
			cout << _a2 << endl;
		};
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

函数对象与lambda表达式

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

int main()
{
	double rate = 0.03;

	Rate r1(rate);
	cout << r1(10000, 2) << endl;//600

	auto r2 = [rate](double money, int year)->double
	{
		return rate * money * year;
	};

	cout << r2(10000, 2) << endl;//600
}

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，然后再调用重载的operator()。

在C++中，lambda表达式通过捕获列表捕获外部变量，并将这些变量作为成员变量存储在lambda对象中。lambda对象的调用本质上是调用其 operator() 成员函数。

捕获列表和成员变量

捕获列表：
- 捕获列表用于指定 lambda 表达式可以访问哪些外部变量。
- 捕获列表中的变量会被存储为 lambda 对象的成员变量。
成员变量：
- 捕获的变量在 lambda 对象内部被存储为成员变量。
- 捕获列表中的变量可以通过值捕获（=）或引用捕获（&）。

构造函数的初始化参数

构造函数：
- lambda 对象的构造函数会使用捕获列表中的变量来初始化成员变量。

调用 operator() 成员函数

调用：
- 当你调用 lambda 对象时，实际上是调用了其 operator() 成员函数。
- operator() 成员函数包含了 lambda 表达式的主体代码。

在这里插入图片描述

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，这个类的名字是lamba + uuid 并且会在在该类中重载operator()。

包装器

function包装器

template <class T> function;     // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;
//模板参数说明：
//Ret: 被调用函数的返回类型
//Args…：被调用函数的形参

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

包装器包装的是可调用对象，可调用对象一般有三类：函数指针（类型不好写），仿函数（需要单独写一个类），lamba（没办法写类型）。

//普通函数
int f(int a, int b)
{
	return a + b;
}
//仿函数
struct Functor
{
public:
	int operator()(int a, int b)
	{
		return a + b;
	}
};

int main()
{
	//function包装可调用对象,可以统一类型
	function<int(int, int)> f1 = f;
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b)->int {return a + b; };

	return 0;
}

通过一个命令就对应一个动作，也就是说一个字符串对应一个函数（可调用对象），这里我们会通常使用map实现，但是map的第二个参数可能是函数指针，仿函数对象，lamba对象。

如果第二个参数个函数指针的话虽然可以实现但是函数指针类型写起来太麻烦，如果用仿函数的类型实现的话就只能固定死一种类型，lamba表达式没有类型，所以这里就可以使用function来实现，可接受各种类型。

int main()
{
	function<int(int, int)> f1 = f;
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b)->int {return a + b; };

	map < string, function<int(int, int)>> opFuncMap;
	opFuncMap["函数指针"] = f1;
	opFuncMap["仿函数"] = f2;
	opFuncMap["lamba"] = f3;

	cout << opFuncMap["函数指针"](2, 3) << endl; //5
	cout << opFuncMap["仿函数"](2, 3) << endl;	// 5
	cout << opFuncMap["lamba"](2, 3) << endl;  //5
	
	return 0;
}

function包装器简化代码，求解逆波兰表达式的步骤如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;  // 创建一个栈用于存储中间结果

        // 定义一个映射，将字符串操作符映射到对应的 lambda 表达式
        map<string, function<int(int, int)>> op = 
        {
            {"+", [](int a, int b) { return a + b; }},
            {"-", [](int a, int b) { return a - b; }},
            {"*", [](int a, int b) { return a * b; }},
            {"/", [](int a, int b) { return a / b; }}
        };

        // 遍历输入的逆波兰表达式
        for (const auto& str : tokens) {
            // 如果当前字符串是操作符
            if (op.count(str)) {
                // 从栈中弹出两个操作数
                int right = st.top();
                st.pop();

                int left = st.top();
                st.pop();

                // 应用对应的操作符，并将结果压入栈中
                st.push(op[str](left, right));
            } else {
                // 如果当前字符串是数字，将其转换为整数并压入栈中
                st.push(stoi(str));
            }
        }

        // 栈顶元素即为最终结果
        return st.top();
    }
};

function还可以包装成员函数。

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 = Plus::plusi;
	//包装普通成员函数
	Plus p;
	function<double(Plus* ,double, double)> f2 = &Plus::plusd;
	cout << f2(&p, 1.1, 2.0) << endl;

	function<double(Plus, double, double)> f3 = &Plus::plusd;
	cout << f3(p, 1.1, 2.0) << endl;
	
	return 0;
}

注意：

规定类的成员函数名取地址才是成员函数的地址。
成员函数的第一个默认的参数是this指针，这里为什么这里的第一个参数用对象也可以呢？

其实包装器包装对象的本质也是一个仿函数，实际要包装的对象作为自己的成员变量这样的方式存起来，然后调用operator()，operator()函数里面再去要包装的可调用对象，所以，这里的第一个参数只是为了调用operator()，所以这里使用指针，对象都可以调用成员函数。

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函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：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为第二个参数，以此类推。

int Sub(int a ,int b)
{
	return a - b;
}

int SubX(int a, int b,int c)
{
	return a - b - c;
}

using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int main()
{
	//调整参数顺序
	auto sub1 = bind(Sub, _1, _2);
	cout << sub1(10, 5) << endl;

	//绑定本质返回是防函数
	//调整参数顺序
	//_1代表第一个实参
	//_2代表第二个实参


	auto sub2 = bind(Sub, _2, _1);
	cout << sub2(10, 5) << endl;

	//调整参数个数
	auto sub3 = bind(Sub, 100, _1);
	cout << sub3(5) << endl;

	auto sub4 = bind(Sub, _1, 100);
	cout << sub3(5) << endl;

	auto sub5 = bind(SubX, 100, _1, _2);
	cout << sub5(5, 10);

	auto sub6 = bind(SubX, _1,100, _2);
	cout << sub6(5, 10);

	auto sub7 = bind(SubX, _1, _2, 100);
	cout << sub7(5, 10);


}

function在包装成员函数的时候第一个参数显示传比较麻烦这里就可以使用bind进行绑定。

//bind一般用于绑定一些固定参数
function<double(double, double)> f3 = bind(&Plus::plusd, Plus(), _1, _2);

int main()
{
	auto func = [](double rate, double money, int year)->double
	{
		int ref = 0;
		
		for (size_t i = 0; i < year; i++)
		{
			ref += money * rate;
			money += money * rate;
		}
		
		return ref;
	};

	function<double(double)> func_3_1_5 = bind(func, 0.015, _1, 3);
	function<double(double)> func_5_1_5 = bind(func, 0.015, _1, 5);
	function<double(double)> func_30_1_5 = bind(func, 0.015, _1, 30);
		
	cout << func_3_1_5(100000) << endl;
	cout << func_3_1_5(100000) << endl;
	cout << func_3_1_5(100000) << endl;

	return 0;
}