文章目录

1. 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]));

	for (const auto& e : array)
		cout << e << " ";

	cout << endl;

	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());

	for (const auto& e : array)
		cout << e << " ";

	return 0;
}

结果如下所示：

在这里插入图片描述

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

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

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 CompareEvaluateGreater
{
	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());   // 价格升序
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._price << endl; // 打印
	}

	cout << "-------------------" << endl;

	sort(v.begin(), v.end(), ComparePriceGreater()); // 价格降序
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._price << endl; // 打印
	}
	
	return 0;
}

我们可以打印，看一下结果：

在这里插入图片描述

同时，我们还可以对商品的评价进行排序，代码如下：

// 用仿函数来实现【评价降序】
struct CompareEvaluateGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._evaluate > gr._evaluate;
	}
};

// 用仿函数来实现【评价升序】
struct CompareEvaluateLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._evaluate < gr._evaluate;
	}
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

	sort(v.begin(), v.end(), CompareEvaluateLess());   // 评价升序
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._evaluate << endl; // 打印
	}

	cout << "-------------------" << endl;

	sort(v.begin(), v.end(), CompareEvaluateGreater()); // 评价降序
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._evaluate << endl; // 打印
	}

	return 0;
}

结果如下：

在这里插入图片描述

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

因此，在 C++11 语法中出现了 Lambda 表达式。

2. lambda 表达式语法

lambda 表达式书写格式为：

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

表达式各部分说明：

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

注意：

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

参考代码如下：

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};

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

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

	// 各部分都很完善的lambda函数
	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 << add_x(10) << endl;

	return 0;
}

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

2.1 lambda 表达式的使用

  • 用 lambda 表达式来比较大小
int main()
{
	// 局部的匿名函数对象
	// [] --> 捕捉列表
	// () --> 参数
	// bool --> 返回值
	// return x < y --> 函数体
	auto less = [](int x, int y)->bool {return x < y; };
	cout << less(1, 2) << endl;
	
	return 0;
}

结果如下：1 < 2 为真

在这里插入图片描述

  • 对商品价格进行降序
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
	
	// 价格降序
	auto goodsPriceLess = [](const Goods& x, const Goods& y)->bool {return x._price > y._price; }; 
	sort(v.begin(), v.end(), goodsPriceLess);

	for (const auto& e : v)
	{
		cout << e._name << " : " << e._price << endl; // 降序打印
	}
	cout << "-------------------" << endl;

	return 0;
}

结果如下：

在这里插入图片描述

  • 对商品价格进行升序（有 auto，故可以省略返回值）
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

	// 另外返回值也可以省略
	auto goodsPriceGreater = [](const Goods& x, const Goods& y){return x._price < y._price; };
	sort(v.begin(), v.end(), goodsPriceGreater);
	
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._price << endl; // 升序打印
	}
	
	cout << "-------------------" << endl;
	return 0;
}

结果如下：

在这里插入图片描述

  • 同样，我们还可以直接把 lambda 表达式写在 sort 函数体中内部
nt main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
	
	// 简洁用法
	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._evaluate > y._evaluate;}); // 评价降序
		
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._evaluate << endl; // 评价降序
	}

	cout << "-------------------" << endl;

	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._evaluate > y._evaluate; }); // 评价升序
		
	for (const auto& e : v)
	{
		cout << e._name << " : " << e._evaluate << endl; // 评价升序
	}
	
	return 0;
}

结果如下：

在这里插入图片描述

3. 捕获列表说明

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

其中：

  • [var]：表示值传递方式捕捉变量 var。
int main()
{
	int a = 1, b = 2;
	double rate = 2.5;

	// 捕捉列表
	auto add1 = [rate](int x, int y) {
		return (x + y) * rate; 
	}; // [rate]传值捕捉

	cout << add1(a, b) << endl;

	return 0;
}

结果如下：

在这里插入图片描述

  • [=]：表示值传递方式捕获所有父作用域中的变量（包括 this）。
int main()
{
	int a = 1, b = 2;
	double rate = 2.5;

	// 捕获所有父作用域中的变量
	auto add2 = [=](){return (a + b) * rate; }; 
	cout << add2() << endl;

	return 0;
}

结果如下：

在这里插入图片描述

  • [&var]：表示引用传递捕捉变量 var。
int main()
{
	int x = 0, y = 2;

	// mutable让捕捉的x和y可以改变，但他们依旧是外面x和y的拷贝
	auto swap1 = [x, y]() mutable {
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap1();
	cout << x << " : " << y << endl;

	// 如果想要修改，就采用 引用的方式捕捉
	auto swap2 = [&x, &y]() mutable {
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap2();
	cout << x << " : " << y << endl;

	return 0;
}

结果如下：

在这里插入图片描述

  • [&]：表示引用传递捕捉所有父作用域中的变量（包括 this）。
int main()
{
	int a = 0, b = 1, c = 2, d = 3;

	// 引用捕捉所有对象, 另外()也可以省略
	auto func1 = [&] (){
		a++;
		b++;
		c++;
		d++;
	};
	func1();
	cout << a << " : " << b << " : " << c << " : " << d << endl;

	return 0;
}

结果如下：

在这里插入图片描述

  • [this]：表示值传递方式捕捉当前的 this 指针。

几个注意点：

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

例如：引用捕捉所有对象，除了 a

int main()
{
	int a = 0, b = 1, c = 2, d = 3;

	// 引用捕捉所有对象, 除了a
	auto func2 = [&, a] {
		// a++; 这一句会报错，此时不能再使用 a 变量了
		b++;
		c++;
		d++;
	};
	func2();
	cout << a << " : " << b << " : " << c << " : " << d << endl;

	return 0;
}

结果如下：

在这里插入图片描述

另外，还可以捕捉局部的 lambda 函数（貌似没啥用处）

int main()
{
	int a = 0, b = 1, c = 2, d = 3;

	auto func1 = []() {
		cout << "hello func1()" << endl;
	};

	// 捕捉函数
	auto func2 = [&, func1] {
		a++;
		b++;
		c++;
		d++;
		func1();
	};
	func2();
	cout << a << " : " << b << " : " << c << " : " << d << endl;

	return 0;
}

结果如下：

在这里插入图片描述

还有一点需要注意的是：

  • lambda 表达式之间不能相互赋值，即使看起来类型相同。

代码如下所示：

int main()
{
	auto f1 = [](int x, int y) {
		return x + y;
	};
	auto f2 = [](int x, int y) {
		return x + y;
	};

	f1 = f2; // 编译失败--->提示找不到operator=()

	return 0;
}

结果如下：

在这里插入图片描述

为什么不能赋值呢？

我们使用 typeid().name() 打印可以看到，这两个 lambda 的类型是不一样的，故无法赋值。

在这里插入图片描述

但是，可以进行其他拷贝操作：

void (*PF)();

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

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

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

结果如下：

在这里插入图片描述

4. 函数对象与 lambda 表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了 operator() 运算符的类对象。

class Rate
{
public:
	// 构造
	Rate(double rate) : _rate(rate)
	{}

	// 重载operator()
	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 表达式通过捕获列表可以直接将该变量捕获到。

我们现在通过调试以后，转到 r1(10000, 2); 的反汇编代码：

在这里插入图片描述

再转到转到 r2(10000, 2); 的反汇编代码：

在这里插入图片描述

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

  • 如果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator()。
  • 也就是说，lambda 底层就是仿函数，就好比 [ ] 捕捉列表还是相当于 “传参”。
# c++ # 开发语言
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区