C++11_lambda表达式

最新推荐文章于 2024-05-17 11:10:00 发布
最新推荐文章于 2024-05-17 11:10:00 发布
阅读量1.1k 收藏 6
点赞数 3
分类专栏： C++的那点事 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yue152152/article/details/127310956
版权

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 _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());//加个降序排序
}

如果要对价格进行排序（升序、降序）则需要手动写两个类，提供比较方法

如果要对名字、评价……进行排序，就要提供更多的类，特别是相同类的命名，
这些都给编程者带来了极大的不便。 因此，在C++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._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; });
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。

lambda表达式语法

lambda表达式书写格式：

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

lambda表达式各部分说明

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

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。

因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

直接看概念有点懵？用一下试试吧

返回值的推导：

int main()
{
	int a = 0, b = 200;
	//捕捉列表  参数  返回值  函数体
	//一般作为局部匿名函数
	auto Add1 = [](int x, int y)->int {return (x + y)/3.0; };
	auto Add2 = [](int x, int y){return (x + y) / 3.0; };//返回值可以省略，自动推到为double
	cout << Add1(a, b) << endl;
	cout << Add2(a, b) << endl;
	
}

捕捉列表：

如果直接在函数体中使用外部的变量，会因为域的不同而无法使用

int main()
{
	int a = 0, b = 200;
	auto Add = []{return a + b; };
}

error C3493: 无法隐式捕获“a”，因为尚未指定默认捕获模式

error C3493: 无法隐式捕获“b”，因为尚未指定默认捕获模式

所以我们就可以使用捕捉列表，把外部的变量捕捉到函数中

int main()
{
	int a = 0, b = 200;
	auto Add = [a, b]{return a + b; };
	cout << Add();
}

mutable

我们尝试用lambda表达式完成一个交换函数：

int main()
{
	int a = 0, b = 200;
	auto Swap = [](int& x, int& y) {
		int tmp = x;
		x = y;
		y = tmp;
	};
	cout << a << "  " << b << endl;
	Swap(a, b);
	cout << a << "  " << b << endl;

}

也可以使用捕获列表交换这里的a,b

int main()
{
	int a = 0, b = 200;
	auto Swap = [a,b] {
		int tmp = a;
		a = b;
		b = tmp;
	};
	cout << a << "  " << b << endl;
	Swap();
	cout << a << "  " << b << endl;
}

但是会报错：

error C3491: “a”: 无法在非可变 lambda 中修改通过复制捕获

error C3491: “b”: 无法在非可变 lambda 中修改通过复制捕获

为了防止用户意外在lambda表达式改变捕获的值，语法默认是不允许对捕获参数赋值的

如果我们想进行修改，就可以使用mutable

int main()
{
	int a = 0, b = 200;
	auto Swap = [a,b]()mutable{//mutable前必须有()
		int tmp = a;
		a = b; 
		b = tmp;
	};
	cout << a << "  " << b << endl;
	Swap();
	cout << a << "  " << b << endl;

}

注意：mutable前必须有()

但是，发现并没有交换成功

这里mutable只是让传值捕获的变量const属性去掉了，

而里面的a、b可以认为还是外面的拷贝，里面改变无法影响外面

所以我们就要用到传引用捕获，而传引用捕获的时候可以不写mutable，

所以说，这个mutable没啥卵用

捕获列表说明

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

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

引用捕获——[&var]

我们用这个引用捕获完成一下上面的交换

int main()
{
	int a = 0, b = 200;
	auto Swap = [&a, &b]{
		int tmp = a;
		a = b; 
		b = tmp;
	};
	cout << a << "  " << b << endl;
	Swap();
	cout << a << "  " << b << endl;

}

全部捕获——[=]

如果定义了很多的参数，我们想一下全捕获进来就可以用到[=]

int main()
{
	int a = 2, b = 3, c = 4, d = 5, e = 6;
	auto Func = [=]() {
		cout << a << " " << b << " " << c << " " << d << " " << e << endl;
	};
	Func();
}

传引用全部捕捉——[&]

int main()
{
	int a = 0, b = 200;
	auto Swap = [&]{
		int tmp = a;
		a = b; 
		b = tmp;
	};
	cout << a << "  " << b << endl;
	Swap();
	cout << a << "  " << b << endl;

}

混着捕捉

int main()
{
	int a = 2, b = 3, c = 4, d = 5, e = 6;
	auto Func1 = [c,d,&e]() {//c,d传值，e传引用捕获
		e = c + d;
	};
	auto Func2 = [=, &d] {//除了d都传值捕获，d传引用捕获
		d = a * b + c;
	};
	Func1();
	Func2();
}

this指针捕获——[this]

class A
{
public:
	void Func()
	{
		auto InFun = [this] {cout << this->a; };
	}
private:
	int a;
};
int main()
{
	A().Func();
}

这段是硬写的，大可没必要这么访问a，直接捕捉列表里填个a就能访问；

注意事项：

  1. 父作用域指包含lambda函数的语句块

  2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

    比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
    [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

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

  4. 在块作用域以外的lambda函数捕捉列表必须为空。

  5. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

  6. lambda表达式之间不能相互赋值，即使看起来类型相同

    这个底层原理会讲

  7. 可以将lambda表达式赋值给相同类型的函数指针（可能是除了auto，也没有其他内置类型类型可以接收lambda表达式，于是C++就只能找了个相似的接收了，并不是因为lambda表达式是一个函数指针，它其实是个仿函数；至于仿函数怎么换成函数指针，可能是把operator()地址赋过去了，没必要深究）(了解一下，一般不建议使用)

    void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	PF = f1;
	PF();
	return 0;
}

可以吃猪肉了

此时我们再对Goods进行排序

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	auto ComparePriceLess = [](const Goods& g1, const Goods g2) {
		return g1._price < g2._price;
	};
	sort(v.begin(), v.end(), ComparePriceLess);
}

就可以用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._price < g2._price;});
	return 0;
}

这样，一眼就能看出来sort在排什么，而且写起来也不需要再些什么()重载仿函数了，方便了很多。

lambda表达式的底层原理

仿函数

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

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);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;
	};
	r2(10000, 2);
	return 0;
}

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

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。

lambda表达式底层原理

image-20221010004716746

对比仿函数和lambda表达式的汇编代码，不能说很像，只能说一摸一样

所以编译之后的lambda表达式就完全相当于编译器定义了一个类，该类重载了operator()

从汇编代码可以看到，lambda表达式转换之后生成的类的类名是lambda_一串数字

这串数字我们称为uuid，这个uuid是通过算法随机生成的一个不会重复的字符串

所以不同lambda表达式生成的uuid就不同

int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
   f1();
   f2();
	//f1 = f2; // 编译失败--->提示找不到operator=()
	return 0;
}

如上两个看以来一摸一样的lambda表达式却不能相互赋值，就是因为它是不同的类

当然，lambda表达式是允许拷贝构造一个新的副本的：

int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f2(f1);
	f2();
	return 0;
}

总结

lambda表达式就是定义一个可调用的对象/可调用的匿名函数

一般定义在局部

特性：可以深度绑定局部变量

Massachusetts_11
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++11 lambda表达式
12-22
C++11引入了lambda表达式，使得程序员可以定义匿名函数，该函数是一次性执行的，既方便了编程，又能防止别人的访问。 　Lambda表达式的语法通过下图来介绍： 　这里假设我们定义了一个如上图的lambda表达式。...
PB的垃圾回收-GarbageCollect()
居然是我的博客!!!!
05-26 2773
PB的垃圾回收-GarbageCollect()应用环境: Windows server 2008 r2 ,未激活；IIS 6 ；开发工具：pb12.6  数据库：Oracle 问题描述:  使用pb12.X开发的web过程中,发现IIS发布后,每次接口调用后,w3wp.exe 的内存占用都会持续增长.当增长到一定内存时会报错。设置了IIS 应用程序池的各类回收后，发现请求限制的作用比较明显。而虚...
Spark Streaming 编程指南(2.4.3)
shareing
06-02 460
文章目录概述 概述
JDK12新特性
蓝影铁哥的博客
12-01 1160
JDK12新特性
【檀越剑指大厂--jvm】jvm篇
檀越的博客
04-05 790
师从B站河北王校长 1.谈谈你对class文件的了解 class文件是以一组8个字节为基础单位的二进制流,各个数据项严格按照顺序紧凑排列在文件中,中间没有任何分隔符,这使得class文件存储的都是程序运行的必要数据,没有空隙存在. class文件格式采用一种类似c语言结构体的伪结构体老存储数据,这种伪结构体只包含2种数据类型:无符号数和表 无符号数属于基本的数据类型,以u1,u2,u4,u8分别来表示1个字节,2个字节,4个字节,8个字节的无符号数.无符号数可以用来描述数字,索引引用,数量值或者按照ut
C++11之lambda的初探
eskimoer的专栏
03-17 709
1 Lambda结构 2 关于capture 3 关于parameter 4 关于mutable 5 throw() 6 返回值 7 函数体
C++11之Lambda表达式
sinat_41752325的博客
06-08 1215
C++11 Lambda 表达式说明
QT error: C3493: 无法隐式捕获“xxx”，因为尚未指定默认捕获模式
Gu_YuXiang的博客
12-09 198
在学习QT的ActiveX控件时，出现了如下同类的问题，本以为错误与ActiveX代码相关，在中文网上大片搜索后依然无果，并没有找到相关解释，后来重新阅读代码才发现是QT自带的宏定义。QStringLiteral括号内的正确数据类型为字符串常量，即"xxxxx"上图中出现的QStringLiteral代码即为错误所在。所以要想实现代码块的正确写法应该是。
c++中的lambda表达式
斧冰
08-28 473
c++ lambda表达式lambda的组成部分Capture 子句（捕获列表）[ ] 空捕获列表，不捕获任何变量**[=] 拷贝捕获[&] 引用捕获[=, &] 拷贝与引用混合[names] 指定引用或拷贝[this] 捕获 this 指针lambda表达式的嵌套可变lambda指定lambda返回类型lambda抛出异常 在 C++ 11 中，lambda 表达式（通常称为 “...
C++ 11 Lambda表达式
大隐隐于野
04-22 291
C++11的一大亮点就是引入了Lambda表达式。利用Lambda表达式，可以方便的定义和创建匿名函数。对于C++这门语言来说来说，“Lambda表达式”或“匿名函数”这些概念听起来好像很深奥，但很多高级语言在很早以前就已经提供了Lambda表达式的功能，如C#，Python等。今天，我们就来简单介绍一下C++中Lambda表达式的简单使用。 声明Lambda表达式 Lambda表达式完整的声...
LambdaQueryWrapper拷贝后条件无效
wangwenzhe的博客
06-07 432
原因待查。
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++中的Lambda表达式详解
09-04
主要介绍了C++中的Lambda表达式详解,本文讲解了基本语法、Lambda的使用等内容,需要的朋友可以参考下
2022 Java 知识点总结
qq_34377273的博客
10-31 1269
corePoolSize 线程池核心线程大小maximumPoolSize 线程池最大线程数量keepAliveTime 空闲线程存活时间unit 空闲线程存活时间单位workQueue 工作队列：基于数组的有界阻塞队列，按FIFO排序，即先进先出原则。：基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。：一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。
【翻译】.NET 5中的性能改进
kaixincheng2009的专栏
07-15 4146
在.NET Core之前的版本中，其实已经在博客中介绍了在该版本中发现的重大性能改进。从.NET Core 2.0到.NET Core 2.1到.NET Core 3.0的每一篇文章，发...
C++ 之 lambda
xiaozhi
09-28 132
C++ 之 lambda
Java 8 的 Lambda 表达式
devalone 的专栏
06-07 220
Java 8 的 Lambda 表达式 Lambda 表达式是 Java 8 的重要更新，也是一个被广大开发者期待已久的新特性。 Lambda 表达式支持将代码块作为方法参数， Lambda 表达式允许使用更简洁的代码来创建只有一个抽象方法的接口的实例。 这种接口被称为函数式接口。 Lambda 表达式完全可以用于简化创建匿名内部类对象。 public class CommandTest2 {...
QT：遇到的bug及解决方法
Yanjun2i的博客
08-11 1244
遇到的bug及解决方法
c++ const 的多种用途
最新发布
05-17 142
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
c++的lambda表达式捕获this_现代 C++：Lambda 表达式
05-25
Lambda表达式是C++11引入的一种函数对象，可以在需要函数对象的地方使用，比如作为函数参数、返回值等。Lambda表达式的语法形式如下： ``` [capture list](parameters) mutable exception -> return type { // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值