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

于 2024-09-10 21:11:37 发布
阅读量359 收藏 22
点赞数 19
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokr_/article/details/142107318
版权

C++11 ——— lambda表达式

lambda表达式

C++98中的一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

int main()
{
	//int array[] = { 5,2,0,1,3,1,4 };	//C++98
	vector<int> v{ 5,2,0,1,3,1,4 };		//C++11
	
	//默认是小于比较，所以是升序
	sort(v.begin(), v.end());
	
	for (auto e : v)
	{
		cout << e << ' ';
	}
	cout << endl;

	//显示实现大于比较，所以是升序
	sort(v.begin(), v.end(),greater<int>());

	for (auto e : v)
	{
		cout << e << ' ';
	}
	return 0;
}

在这里插入图片描述

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


class Goods {
public:
	Goods(string name, double price, int evaluate)
		: _name(name), _price(price), _evaluate(evaluate) {}

	friend ostream& operator<<(ostream& out, const Goods& g); // 友元声明
	friend class  ComparePriceLess;

	struct ComparePriceGreater {
		bool operator()(const Goods& g1, const Goods& g2) {
			return g1._price > g2._price;
		}
	};

	struct CompareEvaluateLess {
		bool operator()(const Goods& g1, const Goods& g2) {
			return g1._evaluate < g2._evaluate;
		}
	};

	struct CompareEvaluateGreater {
		bool operator()(const Goods& g1, const Goods& g2) {
			return g1._evaluate > g2._evaluate;
		}
	};

private:
	string _name;   // 名字
	double _price;  // 价格
	int _evaluate;  // 评价
};

struct ComparePriceLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};

// 重载输出运算符
ostream& operator<<(ostream& out, const Goods& g) {
	out << left << setw(10) << g._name
		<< setw(10) << g._price
		<< setw(10) << g._evaluate;
	return out;
}

int main() {
	vector<Goods> v1{ {"苹果", 5.2, 5}, {"香蕉", 2.5, 3}, {"梨", 3.5, 4} };

	cout << "原始商品列表：" << endl;
	cout << left << setw(10) << "名称" << setw(10) << "价格" << setw(10) << "评价" << endl;
	cout << "------------------------------" << endl;
	for (const auto& e : v1) {
		cout << e << endl;
	}
	cout << "------------------------------" << endl;

	sort(v1.begin(), v1.end(), ComparePriceLess());
	cout << "按照价格升序：" << endl;
	cout << left << setw(10) << "名称" << setw(10) << "价格" << setw(10) << "评价" << endl;
	cout << "------------------------------" << endl;
	for (const auto& e : v1) {
		cout << e << endl;
	}
	cout << "------------------------------" << endl;

	sort(v1.begin(), v1.end(), Goods::ComparePriceGreater());
	cout << "按照价格降序：" << endl;
	cout << left << setw(10) << "名称" << setw(10) << "价格" << setw(10) << "评价" << endl;
	cout << "------------------------------" << endl;
	for (const auto& e : v1) {
		cout << e << endl;
	}
	cout << "------------------------------" << endl;

	sort(v1.begin(), v1.end(), Goods::CompareEvaluateLess());
	cout << "按照评价升序：" << endl;
	cout << left << setw(10) << "名称" << setw(10) << "价格" << setw(10) << "评价" << endl;
	cout << "------------------------------" << endl;
	for (const auto& e : v1) {
		cout << e << endl;
	}
	cout << "------------------------------" << endl;

	sort(v1.begin(), v1.end(), Goods::CompareEvaluateGreater());
	cout << "按照评价降序：" << endl;
	cout << left << setw(10) << "名称" << setw(10) << "价格" << setw(10) << "评价" << endl;
	cout << "------------------------------" << endl;
	for (const auto& e : v1) {
		cout << e << endl;
	}
	cout << "------------------------------" << endl;

	return 0;
}

在这里插入图片描述

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

lambda表达式概念

Lambda表达式是C++11引入的一种新特性，允许开发者定义匿名函数。它使得函数可以作为参数传递，同时也可以作为返回值返回，从而增强了C++的函数式编程能力。Lambda表达式的语法简洁，能够有效减少代码的冗余，提高可读性和可维护性。

lambda表达式语法

C++中的lambda表达式的基本语法如下：

[capture](parameters) -> return_type {
    // function body
}

此图显示了 Lambda 语法的组成部分：
在这里插入图片描述

  1. [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文的变量，提供lambda函数使用

  2. {paraments} ：参数列表， 普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略

  3. mutable :默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

  4. exception-specification（可选）。

  5. ->returntype 返回值类型。 追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

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

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

int main()
{
	//最简单的lambda表达式，没有意义。
	[] {};

	//省略了参数列表和返回值类型，返回值由编译器推出类型为 int
	int a = 3, b = 3;
	[=] {return a + 3; };

	//省略了返回值类型，无返回值类型
	auto fun1 = [&](int c) {b = a + c; };
	fun1(10);
	cout << a << " " << b << endl;

	//各个部分都齐全
	auto fun2 = [=, &b](int c)->int {return b += a + c; };
	cout << fun2(10) << endl;

	//复制捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable {x *= 2; return a + x; };
	cout << x << " -> " << add_x(10) << endl;


	return 0;
}

在这里插入图片描述
通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。

捕获列表说明

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

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

注意：

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

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
	//f1 = f2; // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

lambda表达式交换两个数

标准写法：传入&参数

int main()
{
	int a = 5, b = 10;
	auto Swap = [](int& x, int& y) {int tmp = x; x = y; y = tmp; };

	Swap(a, b);
	cout << "a: " << a << " b: " << b << endl;

}

在这里插入图片描述

利用捕捉列表进行捕捉:

int main()
{
	int a = 5, b = 10;
	auto Swap = [&]() {int tmp = a; a = b; b = tmp; };

	Swap();
	cout << "a: " << a << " b: " << b << endl;

}

在这里插入图片描述

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表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

因此每个lambda表达式的类型都是不同的，这也就是lambda表达式之间不能相互赋值的原因，我们可以通过typeid(变量名).name()的方式来获取lambda表达式的类型。比如：

int main()
{
	int a = 5, b = 10;
	auto Swap1 = [&]() {int tmp = a; a = b; b = tmp; };
	auto Swap2 = [&]() {int tmp = a; a = b; b = tmp; };


	cout << typeid(Swap1).name() << endl;
	cout << typeid(Swap2).name() << endl;

	return 0;
}

在这里插入图片描述

jokr_q
关注
  • 19
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++11——lambda表达式
weixin_57023347的博客
10-27 8213
目录 前言 一.lambda表达式用法 二.lambda表达式语法 三.lambda表达式的原理 前言 在显示生活中，我们在用手机购物时。总是可以在页面上看到下面这样的选项。 我们知道底层这是通过排序来完成的，但是当我们实现时，要写多个排序算法，写多个仿函数来实现不同变量的比较。 比如下面代码： struct CompareNameSmall; struct CompareNameBig; struct ComparePriceSmall; stru...
详解C++11——lambda表达式
Timlinder的博客
03-16 2294
/ 输出: 16return 0;这些示例展示了Lambda表达式在C++中的灵活性和强大功能，特别是在简化代码和提高表达能力方面。Lambda表达式允许在调用std::sort时提供自定义的排序准则。// 使用Lambda表达式按降序排序});return 0;Lambda表达式是C++11引入的功能，极大地增强了语言的表达能力，使得编写内联函数对象更加简洁和直观。
【C++】C++11——lambda表达式
weixin_60478154的博客
03-21 4135
C++11——Lambda表达式
C++11——Lambda表达式
weixin_39303983的博客
04-24 1087
1. 基本用法 lambda 表达式是 C++11 最重要也是最常用的特性之一，这是现代编程语言的一个特点，lambda 表达式有如下的一些优点： 声明式的编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或函数对象。 简洁：避免了代码膨胀和功能分散，让开发更加高效。 在需要的时间和地点实现功能闭包，使程序更加灵活。 lambda 表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。 1.1 语法形式 lambda 表达式的语法形式简单归纳如下： [capture](pa
C++11——lambda表达式详解
qq_45311905的博客
01-04 1514
引入 lambda表达式形式上比较让人难以理解，但假如我们把它整体当作一个对象，且该对象所对应的类型重载了()运算符。即把lambda表达式的调用与函数对象类比，会容易理解很多。 仿函数的极简形式如下： //lambda表达式 []{cout << "hello lambda" << endl;}; VS //重载()的类 class Functor{ public: void operator()(){ cout << "hello functor"<&l
C++11 —— Lambda表达式
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
01-03 427
1.概述 C++ 11 中的 Lambda 表达式用于定义并创建匿名的函数对象，以简化编程工作。 Lambda 的语法形式如下： [函数对象参数] (操作符重载函数参数) mutable 或 exception 声明 -> 返回值类型 {函数体} 可以看到，Lambda 主要分为五个部分：[函数对象参数]、(操作符重载函数参数)、mutable 或 exception 声明、-> 返...
【C++11】—— lambda表达式
M的博客
01-15 914
lambda表达式的基本使用
C++11特性——lambda表达式
gls_nuaa的博客
06-29 802
.. }使用STL的sort()时，要自定义排序方法。这个时候如果排序策略中要使用function()函数中的局部变量就会特别麻烦。而使用lambda表达式就可以直接进行参数传递。当然这只是lambda表达式的冰山一角，这篇文章会更详细的介绍一下，希望这篇文章能够说明白几个问题：1.lambda表达式是什么以及如何使用？2.lambda表达式使用时的一些原理。因为笔者常用C++，所以就使用C++作为举例的语言啦~...
【C++学习】C++11——lambda表达式 | 可变参数模板 | 包装器
weixin_63726869的博客
05-21 1430
介绍了lambda表达式的用法，原理，可变参数模板，以及function包装器和bind绑定函数。
C++——Lambda表达式
qq_47944751的博客
02-01 1085
Lambda 表达式是 C++11 引入的一种的方式，它允许你在需要函数的地方内联地定义函数，而无需单独命名函数：用于捕获外部变量，在 Lambda 表达式中可以访问这些变量。捕获列表可以为空，也可以包含变量列表 [var1, var2, …]。：与普通函数的参数列表类似，可以为空或包含参数列表 (param1,param2, …)。：Lambda 表达式可以自动推断返回类型auto，也可以显式指定返回类型 -> return_type。如果函数体只有一条返回语句，可以省略返回类型。
Modern C++ 学习笔记 —— lambda表达式篇
小小笑笑川的博客
06-25 910
C++11以来lambda表达式作为最重要的特性之一，本文对其进行了详细的介绍以及常用手法，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
Qt 5——Lambda表达式
流楚丶格念的博客
06-19 4104
C++11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。首先看一下Lambda表达式的基本构成： [capture](parameters) mutable ->return-type { statement } [函数对象参数] (操作符重载函数参数)mutable ->返回值{函数体} ① 函数对象参数 [ ]； [ ]，标识一个Lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义.
【C++干货铺】C++11新特性——lambda表达式 | 包装器
qq_55119554的博客
01-20 1398
本片文章介绍了C++11新特性中的lambda表达式和包装器。
Java笔记——Lambda表达式和Stream流
weixin_44853206的博客
11-24 734
/ 测试类 public class Demo03LambdaBase {// 匿名内部类的方式 fun(new MyFunctionalInter() {System . out . println("匿名内部类的方式！");} });// Lambda表达式的标准格式的方式 fun(() -> {System . out . println("Lambda表达式的标准格式的方式");});
JDK8新特性——Lambda表达式
vlucky_long的博客
10-08 477
Lambda表达式不是Java最早使用的，很多语言就支持Lambda表达式，例如：C++，C#，Python，Scala等。如果有Python或者Javascript的语言基础，对理解Lambda表达式有很大帮助，可以这么说lambda表达式其实就是实现SAM接口的语法糖，使得Java也算是支持函数式编程的语言。Lambda写的好可以极大的减少代码冗余，同时可读性也好过冗长的匿名内部类。 1、Lambda表达式引入 示例1:Runnable实现线程 public void test1(){ new T
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 503
C语言 | Leetcode C语言题解之第389题找不同
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 284
QWidget(c++)嵌入window环境的exe
Linux和C语言（Day10）
最新发布
weixin_65095004的博客
09-10 670
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
C/C++基本语言相关面试题
gopher9511的博客
09-10 791
浅拷贝:浅拷贝在复制对象时，只复制对象中的基本数据类型成员和指针值，而不复制指针指向的内存内容。这意味着复制后的对象中的指针将与原对象共享同一块内存。如果某个对象被析构，而该对象的指针指向的内存也被释放，那么其他共享同一内存的对象可能会访问已释放的内存，导致未定义行为甚至程序崩溃。这种情况称为“双重释放”（double free）。在C++中，如果没有为类定义自定义的拷贝构造函数，编译器提供的默认拷贝构造函数就是浅拷贝。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值