C++11lambda表达式--你了解C++的lambda表达式吗?他的底层是怎样的呢?

阿猿收手吧！

已于 2023-10-19 17:33:30 修改

阅读量81

点赞数

分类专栏：遣返回家的C家家文章标签： c++ 数据库

于 2023-10-19 16:12:44 首次发布

本文链接：https://blog.csdn.net/LHRan_ran_/article/details/133843297

版权

遣返回家的C家家专栏收录该内容

54 篇文章 0 订阅

订阅专栏

文章目录

1.lambda表达式的出现
2.lambda表达式的语法
3.lambda表达式的底层

1.lambda表达式的出现

在这里插入图片描述

1.1C++98对内置类型排序

在这里插入图片描述

int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };

	// 默认按照小于比较，排出来结果是升序
	sort(array, array + sizeof(array) / sizeof(array[0]));

	// 如果需要降序，需要改变元素的比较规则
	sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());

	return 0;
}

1.2C++98对自定义类型排序

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

如果每次比较的逻辑不一样，需要实现多个类，在实现多个类时需要注意类的命名大佬觉得复杂由此lambda表达式出现了

1.3C++11中lambda表达式对数据进行排序

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) {return g1._name < g2._name; });

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

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

	return 0;
}

2.lambda表达式的语法

在这里插入图片描述

2.1lambda表达式语法的介绍

C++11最简单的lambda函数为：[ ]{ }; 该lambda函数不能执行任何操作。
lambda表达式的类型:

2.2lambda表达式语法的讲解

1.交换函数的lambda表达式写法

int main()
{
	/// [ capture - list ] (parameters) mutable -> return-type{ statement }  ///
	
	//两个数相加的lambda
	auto add1 = [](int a, int b) -> int
		{ 
			return a + b; 
		};
	cout << add1(1, 2) << endl;

	//省略返回值
	auto add2 = [](int a, int b)
		{
			return a + b; 
		};
	cout << add2(1, 2) << endl;

	// 交换变量的lambda
	int x = 0, y = 1;
	auto swap1 = [](int& x1, int& x2)->void
		{
			int tmp = x1;
			x1 = x2;
			x2 = tmp;
		};
	swap1(x, y);
	cout << x << ":" << y << endl;
	//省略返回值
	auto swap2 = [](int& x1, int& x2)
	{
		int tmp = x1;
		x1 = x2;
		x2 = tmp;
	};
	swap2(x, y);
	cout << x << ":" << y << endl;
	//不传参数 交换变量的lambda [此样例仅交换该当前栈帧内的变量 没有达到本意] 
	int a = 0, b = 1;
	cout << "原始值" << a << ":" << b << endl;
	auto swap3 = [a, b]()mutable  //返回值类型可省 mutable存在时无参列表不可省
		{
			int tmp = a;
			a = b;
			b = tmp;
		};
	swap3();
	cout << "交换后" << a << ":" << b << endl;

	auto swap4 = [&x, &y]
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	cout << "原始值" << x << ":" << y << endl;
	swap4();
	cout << "交换后" << x << ":" << y << endl;

	return 0;
}

2.捕捉列表捕捉

//[capture - list] (parameters) mutable -> return-type{ statement }
int main()
{
	int a = 0, b = 1;
	//1.值传递方式
	cout << "原始值" << a << ":" << b << endl;
	auto swap1 = [a, b]()mutable  //返回值类型可省 mutable存在时无参列表不可省
		{
			int tmp = a;
			a = b;
			b = tmp;
		};
	swap1();
	cout << "交换后" << a << ":" << b << endl;
	//2.引用传递方式
	auto swap2 = [&a, &b]
		{
			int tmp = a;
			a = b;
			b = tmp;
		};
	cout << "原始值" << a << ":" << b << endl;
	swap2();
	cout << "交换后" << a << ":" << b << endl;

//[capture - list] (parameters) mutable -> return-type{ statement }
	
    //3.值传递方式捕获所有父作用域中的变量(包括this)
	cout << "原始值" << a << ":" << b << endl;
	[=] 
		{
			int aa = a;
			int bb = b;
			int tmp = aa;
			aa = b;
			bb = tmp;
		};
	cout << "交换后" << a << ":" << b << endl;
	//4.引用传递捕捉所有父作用域中的变量(包括this)
	cout << "原始值" << a << ":" << b << endl;
	auto fun1 = [&]
		{
			int tmp = a;
			a = b;
			b = tmp;
		};
	fun1();
	cout << "交换后" << a << ":" << b << endl;
	//5.值传递方式捕捉当前的this指针

}

3.捕捉列表混合捕捉

捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：已经以值传递方式捕捉了所有变量，捕捉a重复

int f = 0;
int func()
{
	int a, b, c, d, e;
	a = b = c = d = e = 1;

	// 全部传值捕捉
	auto f1 = [=]()
		{
			cout << a << b << c << d << e << endl;
		};
	f1();

	//引用传递捕捉变量a和b，值传递捕捉其他变量
	auto f2 = [=, &a, &b]()
		{
			a++;
			b++;
			cout << a << b << c << d << e << endl;
		};
	f2();
	//值传递捕捉变量a和b，引用捕捉其他变量
	auto f2 = [&, a, b]()
		{
			//a++;
			//b++;
			c++;
			d++;
			e++;
			cout << a << b << c << d << e << endl;
		};
	f2();
	//仅能捕捉父作用域中局部变量，捕捉非此作用域或者非局部变量都会导致编译报错
	//if()语句块里的λ表达式仍能捕捉func()语句块
	if (a)
	{
		auto f3 = [&, a]()
			{
				//a++;
				b++;
				c++;
				d++;
				e++;
				f++; //全局变量作用域是整个程序 所以此处可以捕捉
				cout << a << b << c << d << e << endl;
			};
		f3();
	}
	return 0;
}

//仅能捕捉父作用域中局部变量，捕捉非此作用域或者非局部变量都会导致编译报错
//main()语句块里的λ表达式不能捕捉func()语句块
int main()
{
	auto fun = [&, a]()
		{
			//a++;
			b++;
			c++;
			d++;
			e++;
			f++;
			cout << a << b << c << d << e << endl;
		};
	fun();
	return 0;
}

4.不能相互赋值可以拷贝构造可以赋值给函数指针

int main()
{
	auto f1 = []
		{
			cout << "hello world" << endl;
		};
	auto f2 = []
		{
			cout << "hello world" << endl;
		};

	//f1 = f2;  //没有与这些操作数匹配的"="运算符操作数类型为 : lambda[]() - > void = lambda[]()->void

	//拷贝构造
	auto f3(f2);
	f3();
	//赋值给相同类型的函数指针
	void (*PF)();
	PF = f2;
	PF();
	return 0;
}

3.lambda表达式的底层

class Rate
{
public:
	Rate(double rate) 
		: _rate(rate)
	{
	
	}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	cout << r1(10000, 2) << endl;
	// lambda
	auto r2 = [=](double money, int year)->double 
		{
			return money * rate * year;
		};
	cout << r2(10000, 2) << endl;

	auto r3 = [=](double money, int year)->double
		{
			return money * rate * year;
		};
	cout << r3(10000, 2) << endl;

	return 0;
}

在这里插入图片描述

实际上编译器调用lambda表达式的过程完全类似于调用仿函数的过程即一个类对象调用自己的成员函数operator()
查阅资料可得C++11 lambda表达式实际上是一个类 class lambdaxxxx{};
xxx实际上是一个随机字符串用来标识当前这个lambda表达式下面是随机字符串的讲解