【C++】C++11--- lambda表达式

最新推荐文章于 2024-05-25 16:26:55 发布
最新推荐文章于 2024-05-25 16:26:55 发布
阅读量866 收藏 29
点赞数 21
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58963318/article/details/138571579
版权

目录

Lambda表达式概述

Lambda表达式语法定义

Lambda表达式参数详解

Lambda捕获列表

捕获列表总结

Lambda参数列表

可变规则mutable

lambda表达式原理

Lambda表达式概述

当对自定义类型的数据集合进行排序时，需要根据自定义类型的不同属性去实现不同的排序方法，比如对若干商品分别按照价格和数量进行升序或者降序排序；

struct Goods
{
	string _name;// 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		,_price(price)
		,_evaluate(evaluate)
	{}
};

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

sort函数的的第三个参数要求传入的是一个可调用对象，可调用对象有: 函数指针，仿函数，选择通过仿函数自定义比较规则；

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());//按价格升序排序
	vector<Goods>::iterator it1 = v.begin();
	while (it1 != v.end())
	{
		cout << "商品:" << (*it1)._name << " 价格:" << (*it1)._price << " 评价:" <<  (*it1)._evaluate << endl;
		++it1;
	}
	cout << endl;

	sort(v.begin(), v.end(), ComparePriceGreater());//按价格降序排序
	vector<Goods>::iterator it2 = v.begin();
	while (it2 != v.end())
	{
		cout << "商品:" << (*it2)._name << " 价格:" << (*it2)._price << " 评价:" << (*it2)._evaluate << endl;
		++it2;
	}
	cout << endl;
}

运行结果：

随着C++语法的发展，由于上述的写法太复杂，每次为了实现一个比较规则，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，若编程者定义的类名命名不规则，会导致代码可读性变差，因此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; });//按评价降序排序
	return 0;
}

Lambda表达式语法定义

int main()
{               //[捕捉列表] ... {函数体}
	auto func = [=](int x)mutable-> int {x++; std::cout << "x=" << x << std::endl; return x; };
	func(10);
	return 0;
}

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

2.(parameters): 参数列表与普通函数的参数列表一致，若不需要参数传递,则可以连同()一起省略；

3. mutable: 默认情况下，lambda函数是一个const函数即捕捉列表中的变量为const属性(即若以传值方式方式捕获变量/对象，是不可以修改的)，但是可以使用mutable可以取消其常量性, 使用该修饰符时,参数列表不可省略(即使没有参数，也需要带上参数列表)

4. return-type：返回值类型， 用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略，返回值类型明确情况时也可省略，由编译器根据返回对象/变量 对返回类型进行推导，若没有返回对象/变量，认为返回类型为void，所以一般不写返回值类型；

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

Lambda表达式参数详解

Lambda捕获列表

lambda表达式与普通函数最大的区别是除了可以使用参数以外，lambda函数还可以通过捕获列表访问一些上下文中的数据；具体地，捕捉列表描述了上下文中哪些数据可以被lambda使用以及使用方式(以值传递的方式或引用传递的方式)；语法上，在"[ ]"包括起来的是捕获列表，捕获列表由多个捕获项组成，并以逗号分隔；捕获列表有以下几种形式：

  • [] 表示不捕获任何变量
int main()
{
	//lambda表达式本质为匿名函数,该函数无法直接调用
	//若想直接调用,借助auto将其赋值给另一个变量
	auto func=[]{ cout << "Hello Linux!" << endl; };
	func();
	return 0;
}

运行结果：

  • [var]表示以值传递方式捕获变量var
int main()
{
	int a = 10;
	int b = 20;
	auto func=[a,b]{ 
		cout << "a="<<a << endl; 
		//++a; error原因:捕捉列表中的变量为const属性,不可以修改
		cout << "b=" << b << endl;
		//++b; error原因:捕捉列表中的变量为const属性,不可以修改
	};
	func();
	return 0;
}

运行结果：

  • [=]表示以值传递方式捕获所有父作用域的变量（包括this）
int main()
{
	int a = 10;
	int b = 100;
	auto func = [=] {
		std::cout << "a=" << a << std::endl;
		std::cout << "b=" << b << std::endl;
		};
	func();

	return 0;
}

运行结果：

  • [&var]表示以引用传递方式捕捉变量var
int main()
{
	int a = 10;
	auto func = [&a] {
		a = a + 10;
		std::cout << "a=" << a << std::endl;
		};
	func();

	return 0;
}

运行结果：

  • [&]表示以引用传递方式捕捉所有父作用域的变量（包括this）
int main()
{
	int a = 10;
	int b = 20;
	auto func = [&] {
		++a;
		cout << "a=" << a << endl;
		++b;
		cout << "b=" << b << endl;
	};
	func();
	return 0;
}

运行结果：

  • [this]表示以值传递方式捕捉当前的this指针
struct Lambda
{
    void Print() {
        std::cout << "Hello Linux!" << std::endl;
    };
    void lambda() {
        auto func = [this] {
            this->Print();
        };

        func();
    }
};

int main()
{
    Lambda lba;
    lba.lambda();
}

运行结果：

捕获列表总结

  •  父作用域指包含lambda函数的语句块；
  •  语法上捕捉列表可由多个捕捉项组成，并以逗号分割；
  1. 1. [=, &a, &b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	auto function = ([=, &a, &b] {
		++a;
		++b;
		//++c;//error
		std::cout << "a=" << a << std::endl;
		std::cout << "b=" << b << std::endl;
		std::cout << "c=" << c << std::endl;
		}
	);
	function();

	return 0;
}

运行结果：

2.[&, a, this]表示以值传递的方式捕捉变量a 和this，引用传递方式捕捉其它所有变量

struct Lambda
{
    void Print() {
        std::cout << "Hello Linux!" << std::endl;
    };
    void lambda() {
        int a = 10;
        int b = 20;
        auto func = [&,a,this] {
            //++a;//error
            ++b;
            std::cout << "a=" << a << std::endl;
            std::cout << "b=" << b << std::endl;
            this->Print();
        };
        func();
    }
};

int main()
{
    Lambda lba;
    lba.lambda();
}

运行结果：

捕捉列表不允许变量重复传递，否则就会导致编译错误

示例：

  • [=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a，导致编译错误；
  • [&,&a]这里已经以引用传递方式捕捉了所有变量，再捕捉 a 也是一种重复，导致编译错误；

在块作用域以外的lambda函数捕捉列表必须为空（即全局lambda函数的捕捉列表必须为空）

int a = 0, b = 1;
// 在全局中不能捕捉对象,捕捉列表必须为空
//auto func = [a, b](){};//err: 无法在lambda中捕获存放于静态区的变量
auto func = []() {};
int main() 
{
	func();
	return 0;
}

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

Lambda参数列表

Lambda参数列表可以接受输入参数，参数列表是可选的，并且在大多数方面类似于函数的参数列表；

int main()
{
	auto Add = [](int first, int second) {
		return first + second;
	};
	std::cout << Add(100, 200) << std::endl;

	return 0;
}

可变规则mutable

mutable修饰符， 默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性；在使用该修饰符时，参数列表不可省略（即使参数为空）

int main()
{
	int a = 0;
	int b = 0;
	auto func = [&, a]()mutable{ ++a; ++b; std::cout << (a + b) << std::endl; };
	func();
}

运行结果：

lambda表达式原理

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

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即若定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()；

编译器会将一个Lambda表达式生成一个匿名类的匿名对象，并在类中重载函数调用(operator())运算符；

auto print = []{cout << "Hello Linux!" << endl; };

编译器会将上面一句翻译为如下代码：

class lambda_uuid
{
public:
	void operator()(void) const
	{
		cout << "Hello Linux!" << endl;
	}
};
//用构造的类创建对象,print此时就是一个函数对象
auto print = lambda_uuid();

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

因为lambda表达式底层完全按照仿函数的处理方式，lambda表达式在底层会被处理为函数对象，该函数对象对应的类名叫做<lambda_uuid>，类名中的uuid为通用唯一识别码，保证在当前程序当中每次生成的uuid都不会重复，lambda表达式底层的类名包含uuid,这样就能保证每个lambda表达式底层类名都是唯一的；因此每个lambda表达式的类型都是不同的，所以lambda表达式之间不能相互赋值；

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

    //f1 = f2;   //error
	
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();

	// 可以将lambda表达式赋值给相同类型的函数指针
	pf = f2;
	pf();
	return 0;
}

运行结果：

欢迎大家批评指正，博主会持续输出优质内容，谢谢各位观众老爷观看，码字画图不易，希望大家给个一键三连支持~ 你的支持是我创作的不竭动力~

小呆瓜历险记
关注
  • 21
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++11：lambda表达式
Man9o
03-09 8792
通常lambda表达式用于封装一些传递给算法或异步函数的代码。C++11中引入了λ表达式，它可以用来定义一个**内联 (inline)**的函数，作为一个本地的对象或者一个参数。内联函数是一种编译器优化技术，它可以避免函数调用的开销，提高执行效率。λ表达式可以被编译器自动内联展开，从而减少函数调用的次数。但是，并不是所有的λ表达式都会被内联，这取决于编译器的实现和优化策略。
C++11-lambda表达式
weixin_45599288的博客
02-24 852
lambda表达式可变模板参数一级目录二级目录三级目录 可变模板参数 C++11中新增加了可变模板参数，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。掌握可变模板参数的基本使用即可。 可变模板参数的定义： 一级目录 二级目录 三级目录 ...
C++11 --- lambda表达式
sqjddb的博客
07-26 1828
lambda表达式格式 使用方式 原理 捕捉列表
C++11——lambda表达式
weixin_57023347的博客
10-27 8035
目录 前言 一.lambda表达式用法 二.lambda表达式语法 三.lambda表达式的原理 前言 在显示生活中，我们在用手机购物时。总是可以在页面上看到下面这样的选项。 我们知道底层这是通过排序来完成的，但是当我们实现时，要写多个排序算法，写多个仿函数来实现不同变量的比较。 比如下面代码： struct CompareNameSmall; struct CompareNameBig; struct ComparePriceSmall; stru...
C++11---lambda表达式
精致的灰的博客
01-25 921
文章目录C++98中的一个例子lambda表达式的格式lambda表达式的原理 C++98中的一个例子 在C++98中，如果待排序元素为自定义类型，需要用户定义排序时的比较规则： struct Goods { string _name; double _price; }; struct Compare { bool operator()(const Goods& gl, const Goods& gr) { return gl._price <= gr._price; }
C++ 之 QT --- lambda表达式
weixin_43200943的博客
09-19 662
C++11中的Lambda表达式用于定义匿名的函数对象，是一种在调用或作为参数传递时在原位定义匿名函数对象的方式
C++11：lambda表达式详细介绍
热门推荐
luoyayun361的专栏
03-15 1万+
前言 Lambda（匿名函数）表达式是C++11最重要的特性之一，lambda来源于函数式编程的概念，也是现代编程语言的一个特点。 优点如下： 声明式编程风格：就地匿名定义目标函数或函数对象，有更好的可读性和可维护性。 简洁：不需要额外写一个命名函数或函数对象，，避免了代码膨胀和功能分散。 更加灵活：在需要的时间和地点实现功能闭包。 概念及基本用法 lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。语法形式如下： [ capture ] ( params ) opt -> ret
C++ lambda 表达式深剖
qq_61500888的博客
10-16 2217
带你一命通关C++ lambda 表达式 十分钟手撕语法内涵
C++进阶--C++11 lambda表达式
sushang的博客
02-02 958
因此每个lambda表达式的类型都是不同的，这也就是lambda表达式之间不能互相赋值的原因，我们通过typeid(变量名).name()的方式获取lambda表达式的类型。[=]**的方式捕获变量时，编译器也不一定会把父作用域中所有的变量捕获进来，编译器可能只会对lambda表达式中用到的变量进行捕获，没有必要把用不到的变量也捕获进来。但是由于这里是传值捕捉，lambda函数中对a和b的修改不会影响外面的a、b变量，与函数的传值传参是一个道理，因此这种方法无法完成两个数的交换。
c++11新特性--Lambda表达式
yqtao的博客
09-14 3839
在刷题的过程中有时会用到lambda表达式，因此在查阅了相关资料后，写出自己对于lambda表达式的理解，如果有问题，欢迎指出。lambda的优点是：可以编写内嵌的匿名函数，而不必编写独立函数或函数对象，使得代码更加的容易理解和精简。Lambda的形式 [capture] (param) opt->ret{body;}; [] 为捕获对象，可以是外部变量，指针，引用等 () 为参数列
C++11 lambda表达式
12-22
C++11引入了lambda表达式，使得程序员可以定义匿名函数，该函数是一次性执行的，既方便了编程，又能防止别人的访问。 　Lambda表达式的语法通过下图来介绍： 　这里假设我们定义了一个如上图的lambda表达式。...
C++中的Lambda表达式详解
09-04
主要介绍了C++中的Lambda表达式详解,本文讲解了基本语法、Lambda的使用等内容,需要的朋友可以参考下
【最新区块链论文录用资讯】CCF A — S&P 2024 共17篇
软件工程小施同学 的专栏
05-22 1392
Chronos：通过具有瞬态延迟的深度优先级模糊测试来查找实际分布式系统中的超时错误。Pianist：通过完全分布式零知识证明实现可扩展的 zkRollups。SwiftRange：用于机密交易等的简短而有效的零知识范围论证。NURGLE：通过 MPT 操纵加剧区块链状态存储的资源消耗。Specular：迈向安全、信任最小化的乐观区块链执行。欺骗加密骗子：基于加密货币的技术支持诈骗的端到端分析。更大规模的中本聪式区块链不一定能提供更好的安全性。SoK：区块链互操作性的安全性和隐私性。
YOLOv8+PyQt：实时检测（摄像头、视频）
qq_45445740的博客
05-19 261
【代码】YOLOv8+PyQt：实时检测（摄像头、视频）
【C++】初始化列表
qq_46049113的博客
05-19 188
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
【C语言】实现贪吃蛇--项目实践（超详细）
2301_78724721的博客
05-23 914
本次实现贪吃蛇会使⽤到的⼀些Win32 API知识，接下来我们就学习⼀下。
结构化绑定
最新发布
janeqi1987的专栏
05-25 83
为了解决这类问题，C++20标准规定结构化绑定的限制不再强调必须为公开数据成员，编译器会根据当前操作的上下文来判断是否允许结构化绑定。幸运的是，虽然标准是2018年提出修改的，但在我实验的3种编译器上，无论是C++17还是C++20标准，以上代码都可以顺利地通过编译。当在结构体或者类中使用结构化绑定的时候，需要有公开的访问权限，否则会导致编译失败。在上面这段代码中，foo是结构体A的友元函数，它可以访问A的私有成员i。在C++20之前，lambda不能直接捕获结构化绑定的变量的。
文件操作（C语言）
2303_76654613的博客
05-19 715
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
lambda表达式C++
09-13
Lambda表达式是现代C++中的一个新特性，它是一种方便的语法糖，用于定义匿名函数对象。Lambda表达式可以在调用或作为函数参数传递的位置处定义几行代码的匿名函数对象。 Lambda表达式在C++11、C++14、C++17和C++20中都得到了支持，并且其使用方法和内容在不同版本中有所更新。 在C++中，Lambda表达式可以被称为Lambda函数、Lambda表达式或匿名函数，但为了方便叙述，本文中统一使用Lambda表达式这个术语。 Lambda表达式的语法如下： ``` [capture-list](parameters) mutable(optional) exception-specification(optional) -> return-type(optional) { // 函数体 } ``` 其中，`capture-list`表示捕获列表，用于指定Lambda表达式中需要捕获的外部变量；`parameters`表示参数列表；`mutable`表示可选的修饰符，用于取消Lambda函数的常量性；`exception-specification`表示异常说明；`return-type`表示返回类型；`函数体`表示Lambda函数的具体实现。 下面是一个Lambda表达式的示例： ```cpp #include <iostream> #include <algorithm> int main() { int m = 0; int n = 0; [&n, m](int a) mutable { m = n + a; }(4); std::cout << m << std::endl << n << std::endl; return 0; } ``` 在这个示例中，Lambda表达式通过捕获列表`[&n, m]`捕获了变量`n`和`m`，参数列表为空，`mutable`修饰符使得Lambda函数可以修改捕获的变量，函数体中的代码将`m`的值设置为`n + a`。最后在主函数中调用Lambda函数，并输出`m`和`n`的值。 希望这个回答能够解决你的问题。如果还有其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小呆瓜历险记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值