C++11--lambda表达式

最新推荐文章于 2024-03-16 21:53:44 发布

=eqwe11

最新推荐文章于 2024-03-16 21:53:44 发布

阅读量818

点赞数 15

分类专栏： c++ 文章标签： c++ 开发语言 c++11

本文链接：https://blog.csdn.net/m0_71321720/article/details/129066122

版权

c++ 专栏收录该内容

21 篇文章 13 订阅

订阅专栏

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 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;
	}
};

之后我们如果要使用sort函数直接使用仿函数的匿名对象就可以

vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };

sort(v.begin(), v.end(), ComparePriceLess()); // 按价格升序排序   这里的ComparePriceLess（）其实是一种匿名对象
sort(v.begin(), v.end(), ComparePriceGreater()); //按价格降序排序
sort(v.begin(), v.end(), CompareNumLess());      //按数量升序排序
sort(v.begin(), v.end(), CompareNumGreater());   //按数量降序排序

虽然仿函数确实能够解决这里的问题但是它具有以下问题

在一般的类中成员变量都是私有的如果我们想使用仿函数进行成员变量之间的比较要声明友元函数
仿函数的命名要是不具有可读性我们就很难理解是按照什么比较的

关于第二点问题的解决我们这里提出一种新的解决方案 lambda表达式

lambda表达式语法

lambda表达式的书写格式

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

上面的代码可以修改成：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
	//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._evaluate < g2._evaluate; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._evaluate > g2._evaluate; });
}

捕捉列表

 [capture-list]

该列表总是出现在lambda函数的最前面它的作用跟main函数类似编译器根据它的位置来判断下面的代码是否为lamdba函数捕捉列表能够捕捉上下文中的变量供lambda函数使用

参数列表

(parameters)

与普通函数的参数列表使用方式一致如果没有参数需要传递可以连同小括号一起省略

mutable

mutable

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

返回值类型

->return-type

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

函数体

{statement}

函数体内就是要写函数的主体除了可以使用其参数外还可以使用所有捕获到的变量

lambda函数的参数列表和返回值类型都是可选部分但捕捉列表和函数体是不可省略的因此最简单的lambda函数如下：

int main()
{
	[]{};             //最简单的lambda表达式

	return 0;
}

捕获列表说明

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

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

这里对于捕捉列表的一些名词概念予以说明

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

lambda表达式交换两个数

传统写法

int a = 10;
int b = 20;

auto swap = [](int& x, int& y)->void{
	int z = x;
	x = y;
	y = z;
};

swap(a, b);

因为lambda表达式是一种匿名函数所以无法直接调用如果想要调用我们可以借助auto关键字将其赋值给一个变量用该变量来实现功能
lambda表达式的函数体最后还有一个分号

捕获列表的使用

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

int a = 10;
int b = 20;

auto swap = [&a, &b] // (使用& 捕获所有参数 也可以)
{
	int z = a;
	a = b;
	b = z;
};

swap(); // 我们这里还必须要调用以下这个函数才会使用

传值捕捉

我们的lambda函数默认是具有常属性的它不会修改内部对象的值

所以要先使用mutable关键字省略其常属性但是省略了这个属性之后参数列表就不能省略

int a = 10;
int b = 20;

auto swap = [=]()mutable{
	int z = a;
	a = b;
	b = z;
};

swap();

但是传值传递本质上是对于原始数据的一份临时拷贝它的修改并不会改变原始的数据所以调用了swap函数也不会发生变化

在全局中不能捕捉对象

int a = 0, b = 1;
//在全局中不能捕捉对象
//auto func5 = [a, b](){};
auto func5 = [](){};

如果用了就会报错

函数对象与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 = 1.34;
    Rate r1(rate);
    r1(10000, 2);

    // lambda
    auto r2 = [=](double monty, int year)->double{return monty*rate*year; };

    r2(10000, 2);

    return 0;
｝

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

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

以直接将该变量捕获到

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如

果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()

底层原理，其实是被处理成一个lambda_uuid的一个仿函数类