【C++】C++11语法 ~ lambda 表达式

目录

🌈欢迎来到C++专栏~~ lambda 表达式

---

• (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
• 目前状态：大三非科班啃C++中
• 🌍博客主页：张小姐的猫~江湖背景
• 快上车🚘，握好方向盘跟我有一起打天下嘞！
• 送给自己的一句鸡汤🤔：
• 🔥真正的大师永远怀着一颗学徒的心
• 作者水平很有限，如果发现错误，可在评论区指正，感谢🙏
• 🎉🎉欢迎持续关注！
  

文章目录

• 🌈欢迎来到C++专栏~~ lambda 表达式
• • 一. 概念
  • 二. 语法
  • 三. 捕获方式
  • • 💥相互赋值
  • 四. 底层实现
  • 五. mutable（作用不大）
• 📢写在最后

一. 概念

自 C++11 开始，C++ 有三种方式可以像函数使用的对象 / 类型：

函数指针
仿函数
Lambda 表达式

此处要注意：greater后面的括号是什么时候要加上？（容易混淆）

• 首先我们要清楚，传的是对象还是类型：传的是对象就要加（），如果是类型就不用

言归正传，lambda 表达式本质上就是一个匿名函数

这里举个例子：

struct Items
{
	string _name;  //名字
	double _price; //价格
	int _num;      //数量
};

如果要对若干对象分别按照价格和数量进行升序、降序排序

可以使用 sort 函数，但由于这里待排序的元素为自定义类，如果想按照我们的数据进行排序，只能通过仿函数来实现了，那岂不是要实现6个仿函数？
有点麻烦了

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;
	}
};
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()); //价格降序
	return 0;
}

为此lambda 表达式就横空出世了

二. 语法

lambda 表达式定义：

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

表达式各部分说明：

• [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用
• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略（无参可以省略）
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
  性。使用该修饰符时，参数列表不可省略(即使参数为空)
• ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量

除了捕获列表，Lambda表达式的其它地方其实和普通的函数基本一样，lambda 参数列表和返回值类型都是可有可无的，但捕捉列表和函数体是不可省略的，因此最简单的lambda函数如下：

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

再举个函数相加的例子：

int main()
{
	//两个函数相加
	auto add1 = [] (int a, int b)->int{return a + b; };
	cout << add1(1, 2) << endl;

	//省略返回值
	auto add2 = [](int a, int b){return a + b; };
	cout << add1(1, 2) << endl;

	return 0;
}

如果我们要不传参数，该怎么样实现呢？

三. 捕获方式

Lambda 表达式最基本的两种捕获方式是：按值捕获和按引用捕获

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

注意：

1. 1️⃣父作用域要包含lambda函数语句（一般指的是当前所在的函数（栈帧））
2. 2️⃣语法上捕捉可由多个捕捉项组成，并以逗号分割（就是可以混合着来）

  //混合捕捉：a是引用捕捉，其他都是传值捕捉
  auto f1 = [=, &a]() {
  	cout << a << b << c << d << e << endl;
  };

  f1();

3. 3️⃣捕捉列表不允许变量重复传递，否则就会导致编译错误
4. 4️⃣在块作用域以外的lambda函数捕捉列表必须为空
5. 5️⃣在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都 会导致编译报错。

来个例题：此处的f可以++吗？

int f = 0;
int main()
{
	int a, b, c, d, e;
	a = b = c = d = e = 1;

	//混合捕捉：a是引用捕捉，其他都是传值捕捉
	auto f1 = [=, &a]() {
		f++;
		cout << a << b << c << d << e << endl;
	};

	f1();
	return 0;
}

f为什么可以呢？

• 因为f是全局变量不存在于栈帧里，存在于静态区，哪个位置都可以用它！

复习一下：
对象的作用域和存储区域要分清楚：

• 生命周期是和存储的区域有关系
• 作用域（编译器编译，用的地方能否找到） 局部 —> 全局

💥相互赋值

lambda表达式之间不能相互赋值，就算是两个一模一样的也不行

lambda 表达式会被处理为函数对象，该函数对象对应的类名叫做<lambda_uuid>

类名中的uuid叫做通用唯一识别码，简单来说就是通过算法生成的一串字符串，它具有随机性和不重复性，保证在当前程序中每次生成不同的 uuid，因为 lambda 表达式底层的类名包含 uuid，这就保证了每个 lambda 表达式底层类名都是唯一的！

void (*PF)();
int main()
{
	 auto f1 = []{cout << "hello world" << endl; };
	 auto f2 = []{cout << "hello world" << endl; };
	    
	 f1 = f2;   // 编译失败--->提示找不到operator=()
	            //实例化后的两个lambda类型，类型不一样
	 auto f3(f2);
	 f3();
	 // 可以将lambda表达式赋值给相同类型的函数指针
	 PF = f2;
	 PF();
	 return 0;
}

但是lambda表达式赋值给相同类型的函数指针

就是在我们看来是一样的，但是其底层大有不同！

四. 底层实现

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，就是对（）进行了重载

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
	{
		return base + num;
	};
	add2(1000);
	return 0;
}

对反汇编进行观察：

当创建add对象的时候是构造函数，使用add对象的时候就是会调用 Add 类的 () 运算符重载函数

lambda 表达式同样如此：会调用 <lambda_uuid> 类的构造函数，在使用add2对象时，会调用<lambda_uuid>类的 ()运算符重载函数

其本质就是：lambda表达式在底层被转换成了仿函数

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

五. mutable（作用不大）

在实际使用中，比如实现一个交换函数，我们用 lambda 表达式实现：

int main()
{
	auto swap2 = [x, y]() 
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap2();
	return 0;
}

这里我们发现是传值传参！果然编译不通过，因为传值捕获到的变量默认是不可修改的（const）：

如果要取消其常量属性，就需要在 lambda 表达式中加上 mutable 像这样：

	auto swap2 = [x, y]() mutable    //改变的是形参，实参无影响，所以没用
	{
		int tmp = x;
		x = y;
		y = tmp;
	};

但是捕捉列表是传值捕捉过来的，不影响外面的实参；所以这种方法无法完成交换功能

📢写在最后