C++11_lambda表达式

最新推荐文章于 2024-04-29 22:02:21 发布
最新推荐文章于 2024-04-29 22:02:21 发布
阅读量1.4k 收藏 7
点赞数 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
关注
专栏目录
C++11-lambda表达式
weixin_45599288的博客
02-24 1110
lambda表达式可变模板参数一级目录二级目录三级目录 可变模板参数 C++11中新增加了可变模板参数，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。掌握可变模板参数的基本使用即可。 可变模板参数的定义： 一级目录 二级目录 三级目录 ...
C++中的Lambda表达式详解
09-04
C++中的Lambda表达式是C++11引入的一项重要特性，它允许我们在程序中定义匿名函数，即没有名称的函数。Lambda表达式的引入极大地方便了函数对象的创建和使用，尤其是在处理函数式编程风格的问题时，如C++标准模板库...
C++ lambda 表达式传递的变量默认不可变
点十八的一方天地
10-28 4842
我遇到如下问题： int count=0; listener->onTouchMoved=[count](Touch* t,Event* e){ count++; log("onTouchMoved"); }; Xcode下的编译错误为：Cannot assign to a variable captured by copy
C++11 Lambda表达式（匿名函数）详解
luoyayun361的专栏
05-26 622
使用 STL 时，往往会大量用到函数对象，为此要编写很多函数对象类。有的函数对象类只用来定义了一个对象，而且这个对象也只使用了一次，编写这样的函数对象类就有点浪费。 而且，定义函数对象类的地方和使用函数对象的地方可能相隔较远，看到函数对象，想要查看其 operator() 成员函数到底是做什么的也会比较麻烦。 对于只使用一次的函数对象类，能否直接在使用它的地方定义呢？Lambda 表达式能够解决这...
C++11之Lambda表达式
sinat_41752325的博客
06-08 1507
C++11 Lambda 表达式说明
QT error: C3493: 无法隐式捕获“xxx”，因为尚未指定默认捕获模式
Gu_YuXiang的博客
12-09 510
在学习QT的ActiveX控件时，出现了如下同类的问题，本以为错误与ActiveX代码相关，在中文网上大片搜索后依然无果，并没有找到相关解释，后来重新阅读代码才发现是QT自带的宏定义。QStringLiteral括号内的正确数据类型为字符串常量，即"xxxxx"上图中出现的QStringLiteral代码即为错误所在。所以要想实现代码块的正确写法应该是。
c++中的lambda表达式
斧冰
08-28 567
c++ lambda表达式lambda的组成部分Capture 子句（捕获列表）[ ] 空捕获列表，不捕获任何变量**[=] 拷贝捕获[&] 引用捕获[=, &] 拷贝与引用混合[names] 指定引用或拷贝[this] 捕获 this 指针lambda表达式的嵌套可变lambda指定lambda返回类型lambda抛出异常 在 C++ 11 中，lambda 表达式（通常称为 “...
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++11 lambda表达式
12-22
C++11中的lambda表达式是一种强大的特性，它允许程序员在代码中定义匿名函数，这些函数可以在需要的地方直接使用，而无需预先声明。这极大地方便了代码的编写，特别是对于那些只用一次的函数，同时也增加了代码的...
C++ 中lambda表达式的编译器实现原理
08-31
C++中的Lambda表达式是C++11引入的一项重要特性，它允许程序员在代码中定义匿名函数，并且可以直接在定义的地方使用。Lambda表达式的引入极大地增强了C++的可读性和简洁性，尤其是在处理函数对象和回调函数时。下面...
C++ 11 Lambda表达式
大隐隐于野
04-22 399
C++11的一大亮点就是引入了Lambda表达式。利用Lambda表达式，可以方便的定义和创建匿名函数。对于C++这门语言来说来说，“Lambda表达式”或“匿名函数”这些概念听起来好像很深奥，但很多高级语言在很早以前就已经提供了Lambda表达式的功能，如C#，Python等。今天，我们就来简单介绍一下C++中Lambda表达式的简单使用。 声明Lambda表达式 Lambda表达式完整的声...
LambdaQueryWrapper拷贝后条件无效
wangwenzhe的博客
06-07 549
原因待查。
为什么lamda不能修改外部引用的变量？
MeiBlog
08-02 1073
lamda表达式实际上一个匿名内部类 所以我们的问题可以转向这两个问题： 为什么匿名内部类调用外部引用的时候，外部引用需要用final修饰？ lamda如果才能修改外部引用变量？ 1. 为什么匿名内部类调用外部引用的时候，外部引用需要用final修饰？ 我们在内部类中调用外部的自由变量，即使该变量没有显式的声明final，但是在编译器解析的时候也被定义成一个final变量 这里java内部类引用外部变量近似闭包的概念。我们先来了解一下js中满足闭包的条件： 一个依赖于外部环境自由变量的函数 这.
C++编译器无法捕捉到的8种错误
zacklin的专栏
03-26 691
C++是一种复杂的编程语言，其中充满了各种微妙的陷阱。在C++中几乎有数不清的方式能把事情搞砸。幸运的是，如今的编译器已经足够智能化了，能够检测出相当多的这类编程陷阱并通过编译错误或编译警告来通知程序员。最终，如果处理得当的话，任何编译器能检查到的错误都不会是什么大问题，因为它们在编译时会被捕捉到，并在程序真正运行前得到解决。最坏的情况下，一个编译器能够捕获到的错误只会造成程序员一些时间上的损失，
无法将“lambda 表达式”赋予隐式类型的局部变量
懒人改变世界
07-04 3875
.net里面有点习惯了var了，突然发现有点滥用了。。。var w = m => m.Status == (int)App.Models.TaskStauts.Unassigned; 报错：无法将“lambda 表达式”赋予隐式类型的局部变量 按照以前的习惯，其实还真不会报错。。Func<DB.Task,bool> w = m => m.Status == (int)App.Models.Tas
lambda变量不能被修改和强制修改
烧香猪^(*￣(oo)￣)^的博客
11-24 635
Lambda 的局部变量和内部类成员 final 变量不是一个变量引用对象包含不可变对象　如 String Integer 等局部变量和内部类成员 final 字段指定的引用地址一样即 修改了任何一方的变量里面的属性　另一方也会被修改，内部类变量和局部变量都执行同一个字面常量值不管怎么搞都不会互相影响经过前面发分析得知内部类里面的字段被 final 修饰　常规修改肯定会报错通过反射可以修改　但是完全没必要　因为修改了没作用对局部变量没任何影响。
c++面试八股一
杰克东的专栏
04-29 195
【代码】c++面试八股一。
C++11之lambda表达式
异样旧日的博客
06-25 378
C++中lambda表达式的介绍与使用
C++11系列学习之二-----lambda表达式
生如蚁，美如神
09-06 1980
C++11添加了一项名为lambda表达式的新功能，通过这项功能可以编写内嵌的匿名函数，而不必编写独立函数和函数对象，使得代码更容易理解。 lambda表达式的语法如下所示： [capture_block](parameters) exceptions_specification -> return_type {body} [捕捉块](参数) 异常 -> 返回值类型 {主体} 或者更直
ceil函数使用报错C语言
最新发布
09-12
在C语言中，`ceil` 函数是一个数学库函数，用于计算大于或等于给定数值的最小整数。这个函数是定义在 `<math.h>` 头文件中的，所以如果你在使用 `ceil` 函数时遇到了报错，可能是因为以下几种情况： 1. 如果你没有包含 `<math.h>` 头文件，那么编译器会因为找不到 `ceil` 函数的定义而报错。解决方法是在使用 `ceil` 函数的源文件中添加 `#include <math.h>`。 2. 如果你的编译器设置为严格遵循标准C（比如C99或C11），但是使用了非标准的编译选项，比如 `math.h` 中的某些函数需要特定的编译器标志才能使用，那么可能会报错。确保你的编译选项支持标准数学库函数。 3. 另外一种情况是，如果你在使用 `ceil` 函数之前没有定义一个数值变量，直接调用了 `ceil` 函数，那么编译器也会报错，因为没有指定需要向上取整的数值。 确保你的程序中包含了正确的头文件，并且正确地使用了 `ceil` 函数。下面是一个简单的例子，演示了如何使用 `ceil` 函数： ```c #include <stdio.h> #include <math.h> int main() { double value = 3.14; double result = ceil(value); printf("The smallest integer greater than or equal to %f is %f.\n", value, result); return 0; } ``` 如果在使用 `ceil` 函数时遇到错误，请检查以上几点是否都正确处理。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值