【】lambda表达式

news2024/11/22 9:19:35

文章目录

  • lambda表达式
    • lambda概念
    • lambda表达式的格式
      • 关于捕获列表
      • 常见问题:
    • 使用lambda表达式交换两个数
    • lambda表达式底层原理

lambda表达式

lambda概念

lambda表达式本质是一个匿名函数(因为它没有名字),恰当使用lambda表达式可以让代码变得简洁.并且可以提高代码的可读性

例子:现在要对若干商品分别按照价格和数量进行升序,降序排序

struct Goods
{
	string _name;  //名字
	double _price; //价格
	int _num;      //数量
    Goods(){}
    Goods(string name,double price,int num)
        :_name(name),_price(price),_num(num)
    {}
};

1)要对一个数据集合中的元素进行排序.可以使用sort函数.但由于这里待排序的元素为自定义类型.因此需要用户自行定义排序时的比较规则

2)要控制sort函数的比较方式常见的有两种方法.一种是在类里面对()运算符进行重载.另一种是通过仿函数来指定比较的方式

  • 在这里通过重载商品类的()运算符是不可行的.因为这里要求分别按照价格和数量进行升序、降序排序.每次排序就去修改一下比较方式是很笨的做法

3)sort函数的的第三个参数要求传入的是一个可调用对象

  • 可调用对象有: 函数指针,仿函数(也称为函数对象,这个类型的对象可以像函数使用), lambda表达式 ,包装器

image-20221017104648175

所以这里选择传入仿函数来指定排序时的比较方式,

struct ComparePriceLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};
struct CompareNumLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num < g2._num;
	}
};
struct CompareNumGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num > g2._num;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	sort(v.begin(), v.end(), ComparePriceLess());    //按价格升序排序
	sort(v.begin(), v.end(), ComparePriceGreater()); //按价格降序排序
	sort(v.begin(), v.end(), CompareNumLess());      //按数量升序排序
	sort(v.begin(), v.end(), CompareNumGreater());   //按数量降序排序
	return 0;
}

仿函数确实能够解决这里的问题,但是我们可以提出更简便的方式:使用lambda表达式

int main()
{
	vector<Goods> v={{"苹果",2.1,300}, {"香蕉",3.3,100}, {"橙子",2.2,1000},{"菠萝",1.5,1 }};
    //sort里面调用这个可调用对象进行比较
	//auto priceLess = [](const Goods& g1, const Goods& g2){return g1._price < g2._price; };
	//sort(v.begin(), v.end(), priceLess);
	//简写：
    
	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._num < g2._num;//按数量升序排序
	}); 
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
		return g1._num > g2._num;//按数量降序排序
	}); 
	return 0;
}

这样一来.每次调用sort函数时只需要传入一个lambda表达式指明比较方式即可.阅读代码的人一看到lambda表达式就知道本次排序的比较方式是怎样的.提高了代码的可读性.

lambda表达式的格式

lambda表达式书写格式：**[capture-list] (parameters) mutable -> return-type {statement }; **

​ [ 捕捉列表 ] ( 形参 ) 约束(可选) -> 返回值类型(可选) {函数体}

image-20221017105719255

lambda表达式各部分说明

1) [capture-list] : 捕捉列表,该列表总是出现在lambda函数的开始位置,编译器根据[]来判断接下来的代码是否为lambda函数,捕捉列表能够捕捉和lambda表达式同一个作用域的对象(换一种说法就是:能够捕捉上下文中的变量)给lambda函数使用,如果没有变量需要捕捉,那[]里面的内容可以不写

2) (parameters)：参数列表, 与普通函数的参数列表一致,如果不需要参数传递,则可以连同()一起省略

  1. mutable：默认情况下,lambda函数总是一个const函数,(如果以传值方式方式捕获变量,是不可以修改的),但是可以使用mutable可以取消其常量性, 使用该修饰符时,参数列表不可省略(即使没有参数,而需要带上参数列表)

4)return-type：返回值类型, 用追踪返回类型形式声明函数的返回值类型,没有返回值时此部分可省略,返回值类型明确情况下也可省略,由编译器对返回类型进行推导,所以一般不写返回值

  1. {statement}：函数体, 在该函数体内,除了可以使用其参数外,还可以使用所有捕获到的变量

lambda函数的参数列表和返回值类型都是可选部分,但捕捉列表和函数体是不可省略的

  • 因此最简单的lambda函数为:[]{}; //最简单的lambda表达式 ,该lambda函数不能做任何事情,注意lamber表达式后面的分号！！！

关于捕获列表

捕获列表描述了上下文中哪些数据变量可以被lambda函数使用,以及使用的方式是传值还是传引用

  • [var]：表示值传递方式捕捉变量var
  • [=]：表示值传递方式捕获所有父作用域中的变量（成员函数中包括this指针）
  • [&var]：表示引用传递捕捉变量var
  • [&]：表示引用传递捕捉所有父作用域中的变量 （成员函数中包括this指针）
  • [this]：表示值传递方式捕捉当前的this指针 ,注意:this无法通过引用捕获！

常见问题:

  • 父作用域指的是包含当前lambda函数的语句块
  • 语法上捕捉列表可由多个捕捉项组成,并以逗号分割
    • 比如[=, &a, &b]:表示的是:以值传递方式捕获父作用域中其它变量,以引用传递捕捉变量a和变量b
  • 捕捉列表不允许变量重复传递,否则会导致编译错误
    • 比如[=, a] [=]已经以值传递方式捕获了a,然后又以传值捕获a,重复了 但是可以[=,&a]
  • 在块作用域中的lambda函数仅能捕捉父作用域中的局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错
  • lambda表达式之间不能相互赋值.即使看起来类型相同
  • 在块作用域以外的lambda函数捕捉列表必须为空.即全局lambda函数的捕捉列表必须为空.
int a = 0, b = 1;
// 在全局中不能捕捉对象,捕捉列表必须为空
//auto func5 = [a, b](){};//报错！
auto func5 = [](){};
int main(){}

使用lambda表达式交换两个数

如果要用lambda表达式交换两个数.可以有以下几种写法：

标准写法:

参数列表中包含两个形参.表示需要交换的两个数,注意:必须需要以引用的方式传递

int main()
{
	int a = 10, b = 20;
	auto Swap = [](int& x, int& y)->void //两个参数为引用类型
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	Swap(a, b); //交换a和b
	return 0;
}

说明:lambda表达式是一个匿名函数.该函数无法直接调用,如果想要直接调用,可借助auto自动推导类型,将其赋值给一个变量,此时这个变量就可以像普通函数一样使用

  • lambda表达式的函数体在格式上并不是必须写成一行,如果函数体太长可以进行换行,但换行后不要忘了函数体最后还有一个分号.

写法2:利用捕捉列表进行捕捉变量

以引用的方式捕捉所有父作用域中的变量,可以省略参数列表和返回值类型

int main()
{
	int a = 10, b = 20;
	auto Swap = [&] //以引用方式捕获当前作用域的变量
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b
	return 0;
}

因为此时对变量进行了捕捉,所以调用lambda表达式时就不用传入参数了, 但实际我们只需要用到变量a和变量b.没有必要把父作用域中的所有变量都进行捕捉,因此也可以只对父作用域中的a、b变量进行捕捉

int main()
{
	int a = 10, b = 20;
	auto Swap = [&a, &b]{  //以引用方式捕获变量a和b
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b
	return 0;
}

说明:当我们以[&]或[=]的方式捕获变量时,编译器也不一定会把父作用域中所有的变量捕获进来,编译器可能只会对lambda表达式中用到的变量进行捕获,没有必要把用不到的变量也捕获进来,这个主要看编译器的具体实现

如果要以传值方式捕捉呢?

以传值方式进行捕捉,首先编译不会通过,因为传值捕获到的变量默认是不可修改的,如果要取消其常量性,就需要在lambda表达式中加上mutable约束,并且此时参数列表不可省略

int main()
{
	int a = 10, b = 20;
  	//[a,b](){} 这样是传值捕捉a和b,本质就是把a和b拷贝一份过来,并且a和b还是const的
    //以值传递方式捕捉变量a和b, 使用mutable取消lambda的常量性
	auto Swap = [a, b]()mutable  //此时参数列表不可以省略！！
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b？ 不可以！因为是以值传递方式捕获
	return 0;
}

但由于这里是传值捕捉.lambda函数中对a和b的修改不会影响外面的a、b变量.与函数的传值传参是一个道理.因此这种方法无法完成两个数的交换

练习：实现一个两个数相加的lambda表达式

int main()
{
	auto add1 = [](int a, int b)->int {
		return a + b;
	};
	auto add2 = [](int a, int b) {	// 返回值类型可以省略
		return a + b;
	};

	//如果此时我们想定义一个和add1一样类型的对象:
	//方法1:使用auto推导
	auto add3 = add1;
	//方法2:使用decltype
	decltype(add1) add4 = add1;
    
    //注意:此时add1和add3和add4的类型都是一样的！！！lambda_uuid是一样的
	cout << typeid(add1).name() << endl;
	cout << typeid(add3).name() << endl;
	cout << typeid(add4).name() << endl;
    
	cout << add1(10, 20) << " " << add2(10, 20) << " " 
		<< add3(10, 20) << " " << add3(10, 20) << " " << endl;
	return 0;
}

lambda表达式底层原理

实际编译器在底层对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,函数对象就是我们平常所说的仿函数,就是在类中对()运算符进行了重载的类对象,

例如:下面编写了一个Add类,该类对()运算符进行了重载,因此Add类实例化出的add1对象就叫做函数对象,add1可以像函数一样使用,然后我们再编写一个lambda表达式,并借助auto将其赋值给add2对象,这时add1和add2都可以像普通函数一样使用

class Add
{
public:
	Add(int base)
		:_base(base)
	{}
	int operator()(int num)
	{
		return _base + num;
	}
private:
	int _base;
};

int main()
{
	int base = 1;

	//函数对象
	Add add1(base);
	add1(1000);

	//lambda表达式
	auto add2 = [base](int num)->int //以值的方式捕获base,有一个参数,返回值是int
	{
		return base + num;
	};
	add2(1000);
	return 0;
}

调试代码并转到反汇编.可以看到在创建函数对象add1时,会调用Add类的构造函数,在使用函数对象add1时,调用Add类的()运算符重载函数

image-20221017103616230

观察lambda表达式时.也能看到类似的代码

  • 借助auto将lambda表达式赋值给add2对象时.会调用<lambda_uuid>类的构造函数.
  • 在使用add2对象时.会调用<lambda_uuid>类的()运算符重载函数.

image-20221017103649582

本质就是因为lambda表达式在底层被转换成了仿函数.

  • 当我们定义一个lambda表达式后,编译器会自动生成一个类,在该类中对()运算符进行重载,实际lambda函数体的实现就是这个仿函数的operator()的实现
  • 在调用lambda表达式时,参数列表和捕获列表的参数,最终都传递给了仿函数的operator()

lambda表达式和范围for是类似的,它们在语法层面上看起来都很神奇,但实际范围for底层就是通过迭代器实现的,lambda表达式底层的处理方式和函数对象是一样的

为什么lambda表达式之间不能相互赋值

就算是两个一模一样的lambda表达式,二者之间不能相互赋值,

  • 因为lambda表达式底层的处理方式和仿函数是一样的,在VS下,lambda表达式在底层会被处理为函数对象,该函数对象对应的类名叫做<lambda_uuid>,
  • 类名中的uuid叫做通用唯一识别码,简单来说,uuid就是通过算法生成一串字符串,保证在当前程序当中每次生成的uuid都不会重复
  • lambda表达式底层的类名包含uuid,这样就能保证每个lambda表达式底层类名都是唯一的

因此每个lambda表达式的类型都是不同的,这也就是lambda表达式之间不能相互赋值的原因,

验证:我们可以通过typeid(变量名),name()的方式来输出lambda表达式的类型,

int main()
{
	int a = 10, b = 20;

	auto swap1 = [&]() {
		swap(a, b);
	};
	swap1();

	auto swap2 = [&]() {
		swap(a, b);
	};
	swap2();
	cout << typeid(swap1).name() << endl;
	cout << typeid(swap2).name() << endl;
	return 0;
}

image-20221017104427932

可以看到,就算是两个一模一样的lambda表达式,它们的类型都是不同的

说明一下： 编译器只需要保证每个lambda表达式底层对应类的类名不同即可,并不是每个编译器都会将lambda表达式底层对应类的类名处理成<lambda_uuid>,这里只是以VS为例

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/473245.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

字节后端入门 - Go 语言原理与实践

字节后端入门 - Go 语言原理与实践

1.1什么是Go语言 1.2Go语言入门 环境 1.3基础语法 1.3.1变量 var name"value" 自己推断变量类型&#xff1b; 也可以显式类型 var c int 1 name: type(value) 常量&#xff1a; const name "value" g : a"foo" 字符串拼接 1.3.2 if else {}花括号…
阅读更多...
Java——多线程和锁

Java——多线程和锁

多线程 前言:当我们打开一个网站时&#xff0c;不同部分的加载并不是先后出现的&#xff0c;是并行出现的&#xff0c;没有出现一个地方没加载完&#xff0c;别的地方就也加载不出来这种事。这个就是多线程并行运行。 当其中一个线程发生阻塞时&#xff0c;操作系统会自动执行…
阅读更多...
系统集成项目管理工程师 笔记（第12章：项目沟通管理和干系人管理）

系统集成项目管理工程师 笔记（第12章：项目沟通管理和干系人管理）

文章目录 12.1.2 沟通的方式 404沟通管理计划的编制过程12.2.2 制订沟通管理计划的工具 4114、沟通方法 12.3.2 管理沟通的工具 41312.4.2 控制沟通的技术和方法 4163、会议 12.5.1 项目干系人管理所涉及的过程 420项目干系人管理的具体内容&#xff1a;&#xff08;1&#xff…
阅读更多...
C/C++文件操作/IO流

C/C++文件操作/IO流

学习任务&#xff1a; ⭐认识文件。⭐学习C语言中文件如何打开和关闭。⭐学习C语言中文件的读写方法&#xff08;包括顺序读写和随机读写&#xff09;。⭐学习C语言文件操作中如何判断文件读取结束。⭐简单了解FILE缓冲区。⭐认识流。⭐学习C的IO流&#xff0c;包括标准IO流和文…
阅读更多...
【CMake】给一个库添加用法需求（Usage Requirements）

【CMake】给一个库添加用法需求（Usage Requirements）

3. 给一个库添加用法需求&#xff08;Usage Requirements&#xff09; 1. usage requirements 目标参数的用法要求&#xff08;不知道有没有更好的翻译方式&#xff09;可以更好地控制库或可执行的链接&#xff0c;并包括行&#xff0c;同时还可以更好地控制CMAKE内部目标的传…
阅读更多...
【哈士奇赠书活动 - 17期】-〖uni-app跨平台开发与应用从入门到实践〗

【哈士奇赠书活动 - 17期】-〖uni-app跨平台开发与应用从入门到实践〗

文章目录 ❤️‍&#x1f525; 赠书活动 - 《uni-app跨平台开发与应用从入门到实践》❤️‍&#x1f525; 编辑推荐❤️‍&#x1f525; 抽奖方式与截止时间❤️‍&#x1f525; 赠书活动 → 获奖名单 ❤️‍&#x1f525; 赠书活动 - 《uni-app跨平台开发与应用从入门到实践》…
阅读更多...
日志技术-Logback

日志技术-Logback

一. 日志是什么&#xff1a; 输出语句的弊端&#xff1a;它只能在控制台展示&#xff0c;它不能记录在本地文件当中。 日志可以将程序运行过程中的信息直接记录在文件里面&#xff0c;做永久存储。 性能较好&#xff0c;简单来说就是运行的速度会比较快。 二. 日志技术体系、L…
阅读更多...
3_docker应用部署:MySQL-Tomcat-Nginx-Redis

3_docker应用部署:MySQL-Tomcat-Nginx-Redis

Docker 应用部署 一、部署MySQL 案例需求&#xff1a;在Docker容器中部署MySQL&#xff0c;并通过外部mysql客户端操作MySQL Server。 分析&#xff1a; 容器内的网络服务和外部机器不能直接通信 外部机器和宿主机可以直接通信 宿主机和容器可以直接通信 当容器中的网络服…
阅读更多...
iOS 17 开放侧载，微信双开要来了？

iOS 17 开放侧载，微信双开要来了？

关于苹果北京时间 6 月 6 日召开的 WWDC23 全球开发者大会&#xff0c;外媒彭博记者 Mark Gurman 带来了最新消息。 大致更新概览 他认为&#xff0c;本次 WWDC23 大会将会主要推出这几款产品和软件&#xff1a;iOS 17、iPadOS 17、macOS 14、watchOS 10、新的 MacBooks 、混…
阅读更多...
文件上传下载系列——如何实现文件秒传

文件上传下载系列——如何实现文件秒传

文章目录 &#x1f383;简介&#xff1a; &#x1f47b;核心思想&#xff1a; MD5是什么&#xff1f; 实现步骤&#xff1a; &#x1f384;实操&#xff1a; 1、java生成文件MD5码 2、javascript生成文件MD5码 ⛳️基于秒传的分片上传下载 上传&#xff1a; 下载&…
阅读更多...
Afkayas.1（★）

Afkayas.1（★）

软件运行 要输入正确的Name和Serial 查壳 一个VB程序&#xff0c;没有加壳 载入OD 直接开搜索字符串。 这里看到了错误的提示&#xff0c;“You Get It”应该就是成功的字符串了。 前面的“AKA-”应该是在什么时候拼接的字符串 去成功的字符串附近看看 这个字符串上面…
阅读更多...
LVS负载均衡群集——DR模式

LVS负载均衡群集——DR模式

一、LVS-DR集群介绍 LVS-DR&#xff08;Linux Virtual Server Director Server&#xff09;工作模式&#xff0c;是生产环境中最常用的一 种工作模式。 1、LVS-DR 工作原理 LVS-DR 模式&#xff0c;Director Server 作为群集的访问入口&#xff0c;不作为网关使用&#xff0…
阅读更多...
第九章 子查询

第九章 子查询

文章目录 前言一、.需求分析与问题解决1 、实际问题2 、子查询的基本使用3 、子查询的分类 二、单行子查询1、单行比较操作符2、代码示例3、 HAVING 中的子查询4、CASE中的子查询5、 子查询中的空值问题6、非法使用子查询 三、多行子查询1、 多行比较操作符2、代码示例3 、空值…
阅读更多...
客快物流大数据项目（一百一十八）：配置中心 Spring Cloud Config

客快物流大数据项目（一百一十八）：配置中心 Spring Cloud Config

文章目录 配置中心 Spring Cloud Config 一、​​​​​​​Config 简介
阅读更多...
STM32-HAL-SPI-W25Q128FV简单读写测试(2)

STM32-HAL-SPI-W25Q128FV简单读写测试(2)

文章目录 一、Flash的基本读写操作1.1 向芯片中的某个地址&#xff08;addr:0x02&#xff09;连续写入不定长的数据并读取代码示例读写流程分析函数分析 1.2 向芯片中的某个地址&#xff08;addr:0x00&#xff09;写入一个数值代码示例&#xff1a;读写流程分析 具体的配置接上…
阅读更多...
react native ios 添加启动页 xcode14

react native ios 添加启动页 xcode14

最近更新xcode&#xff0c;有些配置有些不同&#xff0c;网上查的方法都是过时的&#xff0c;导致配了一段时间卡在这里&#xff0c;最后访问官网才弄好了&#xff0c;所以以后解决问题的办法先看官网再查其他各路神仙的办法。 官网的步骤&#xff1a;https://github.com/crazy…
阅读更多...
MAC 查看已装载的卷宗

MAC 查看已装载的卷宗

查看卷宗目录命令 ls /Volumes网络卷宗&#xff1a;本机、系统报告。 参考资料&#xff1a;https://blog.csdn.net/qq_41731201/article/details/125407204
阅读更多...
建筑行业如何进行高效管理文件？

建筑行业如何进行高效管理文件？

建筑设计行业在日常办公中会产出大量文件&#xff0c;如设计图纸协作商议&#xff0c;项目资料等&#xff0c;建筑行业该如何高效管理文件呢&#xff1f; 建筑设计行业团队可能遇到的文件管理问题&#xff1a; 1&#xff0c;设计图纸一般较大&#xff0c;来回传输不仅麻烦&…
阅读更多...
【矩阵快速幂 | 斐波那契数列 | 矩阵加速】

【矩阵快速幂 | 斐波那契数列 | 矩阵加速】

文章目录 基础知识1. 矩阵结构2. 重载 * 运算符3. 矩阵快速幂 例题1&#xff1a; 矩阵幂求和例题2&#xff1a; 矩阵快速幂例题3&#xff1a; 斐波那契数列例题4&#xff1a; 矩阵加速例题5&#xff1a; 广义斐波那契例题6&#xff1a; 斐波那契公约数例题7&#xff1a; 这个勇…
阅读更多...
设计模式——设计模式介绍和单例设计模式

设计模式——设计模式介绍和单例设计模式

目录 一、设计模式概述和分类 1.1 设计模式介绍 1.2 设计模式分类 二、创建型设计模式-单例模式 2.1 介绍 2.2 八种单例模式的创建方式 2.2.1 饿汉式&#xff08;静态常量&#xff09; 2.2.2 饿汉式&#xff08;静态代码块&#xff09; 2.2.3 懒汉式&#xff08;线程…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023