「学习笔记」Lambda 表达式

仅入门，主要为 C++11 和 C++14 标准，高版本的 Lambda 表达式更复杂，但对竞赛来说一般用不上很复杂的 Lambda 表达式。

---

平时我们使用 sort() 函数进行自定义排序，一般都会写一个函数，像下面这样的。

bool cmp(int a, int b) {
    return a > b;
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    sort(a, a + 5, cmp);
    for (int i = 0; i < 5; ++ i) {
        cout << a[i] << ' ';
    }
    return 0;
}

这个 cmp() 函数的作用就是将数组从大到小排序。

Lambda 表达式，可以直接用来代替 cmp() 函数，用 Lambda 表达式改写上面的代码。

int main() {
	int a[] = {1, 2, 3, 4, 5};
	auto cmp = [&](int a, int b) {
		return a > b;
	};
	sort(a, a + 5, cmp);
	// 或者是这样
	/*
	sort(a, a + 5, [&](int a, int b) {
		return a > b;
	});
	 */
	for (int i = 0; i < 5; ++ i) {
		cout << a[i] << ' ';
	}
	work();
	return 0;
}

尽管第二份代码看着怎么着也比第一份代码更高级，但是，两份代码最后的和输出都是一样的，Lambda 表达式起的作用与 cmp() 函数是一样的。

Lambda 表达式#

Lambda 表达式的语法结构如下。

[捕获](参数) lambda 说明符 {函数体}

通过上面的例子，我们也会察觉，Lambda 表达式只是可以代替一些函数的工作，即 Lambda 表达式能完成的工作也可以被其他 C++ 语法完成，因此，它只是一种语法糖 但也很甜呀。

捕获#

顾名思义，就是捕获变量。

捕获是一个含有零或多个捕获符的逗号分隔列表，有两种默认捕获符。

• & 以引用方式捕获变量。

• = 以复制方式捕获变量。

如果捕获列表中只有一个 &，则默认是引用捕获，同理，如果捕获列表中只有一个 =，则默认是复制捕获，如果为空，则表示 Lambda 表达式的主体不会访问封闭范围内的变量。

当默认捕获符是 & 时，后继的简单捕获符不能以 & 开始。这里经过测试，只会弹出警告页面，但不会报错。

当变量以复制捕获时，如果没有 mutable 标识符，该变量是不能修改的。

下面用几份代码来试验一下。

int main() {
	int a = 2, b = 1, c = 3;
	auto it1 = [&] {
		b = a;
		a = c;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

这份代码里面，默认捕获方式为引用捕获，因此 $a$ 和 $b$ 都以引用捕获，$a$ 和 $b$ 的值都被修改了。最后的输出为 3 2。

int main() {
	int a = 2, b = 1;
	auto it1 = [&, a] {
		b = a;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

在这份代码里面，这个捕获的含义为：默认变量以引用捕获，但是 $a$ 以复制捕获，因此 $b$ 以引用捕获，$b$ 的值被修改了，而 $a$ 以复制捕获，在这里面作为只读变量，值不会被修改。最后的输出为 2 2。

int main() {
	int a = 2, b = 1;
	auto it1 = [&, &a] {
		b = a;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

这份代码与第一份代码输出是一样的，只是会弹出警告。

int main() {
	int a = 2, b = 1;
	auto it1 = [=, &a] {
		a = b;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

这份代码里面，默认是以复制捕获，$a$ 以引用捕获，$a$ 的值会被修改。最后输出 1 1。

int main() {
	int a = 2, b = 1;
	auto it1 = [=, &a] {
		a = b;
		b = a;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

报错，因为 $b$ 是以复制捕获，没有 mutable 标识符是不可以被修改的。

int main() {
	int a = 2, b = 1;
	auto it1 = [] {
		a = b;
		b = a;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

报错，it1 不能捕获 $a$ 和 $b$。

int a = 2, b = 1, c = 3;

int main() {
	auto it1 = [] {
		a = b;
		b = c;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

int a = 2, b = 1, c = 3;

int main() {
	auto it1 = [=] {
		a = b;
		b = c;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

这两份代码的输出都是 1 3，因为全局变量默认以引用捕获，而捕获列表是针对捕获封闭空间的变量的，不会影响到全局变量。

参数#

与函数的参数差不多，下面这两份代码中，最后的输出都是一样的。

int main() {
	int a = 2, b = 1;
	auto it1 = [](int c, int d) {
		c = d;
		return c;
	};
	cout << it1(a, b) << '\n';
	return 0;
}

int it1(int a, int b) {
	a = b;
	return a;
}

int main() {
	int a = 2, b = 1;
	cout << it1(a, b) << '\n';
	return 0;
}

lambda 说明符#

lambda 说明符由说明符、异常说明、属性和尾随返回类型按前述顺序组成，每个组分均非必需，这里只会讲解说明符和尾随返回类型。

说明符

在 CCF 给我们开 C++17 之前，我们能用的说明符有 mutable，另外的几个说明符都需要更高版本的 C++，constexpr 从 C++17 起可以用，consteval 从 C++20 起可以用（constexpr 和 consteval 不能同时使用），static 从 C++23 起才能使用（mutable 和 static 不能同时使用，且使用 static 时，捕获列表必须为空）。

前面我们提到了，当变量以复制捕获时，如果没有 mutable 标识符，该变量是不能修改的，不提供说明符时复制捕获的对象在 Lambda 体内是 const 的。

mutable：允许函数体修改以复制捕获的对象，以及调用它们的非 const 成员函数。

使用了 mutable 说明符，我们就可以修改以复制捕获的变量了，在使用这个标识符时，前面的参数括号不要省略，即使里面为空，否则会弹出警告。

下面的这份代码不加 mutable 是会报错的，因为我们修改了以复制捕获的变量 $b$，只要我们加上一个 mutable 说明符就可以了通过了。最后输出 3 1。（这里我们只是可以在函数体内修改以复制捕获的变量，但该变量本身不是以引用捕获的，因此它本身的值并不会改变）。

int main() {
	int a = 2, b = 1, c = 3;
	auto it1 = [=, &a] () mutable {
		a = b;
		b = c;
		a = b;
	};
	it1();
	cout << a << ' ' << b << '\n';
	return 0;
}

尾随返回类型

用于指定 Lambda 表达式的返回类型。若没有指定返回类型，则返回类型将被自动推断。具体的，如果函数体中没有 return 语句，返回类型将被推导为 void，否则根据返回值推导。

int main() {
	int a = 2, b = 1, c = 3;
	auto it1 = [=, &a] () mutable {
		a = b;
		b = c;
		a = b;
		return a;
	};
	cout << it1() << '\n';
	a = 2, b = 1, c = 3;
	auto it2 = [=, &a] () mutable -> int {
		a = b;
		b = c;
		a = b;
		return a;
	};
	cout << it2() << '\n';
	return 0;
}

代码中的 it1() 与 it2() 效果是一样的，只是 it1() 是根据返回值自动判断的，it2() 是指定的 int 类型。

函数体#

这个其实就是跟函数一模一样了，将你要运行的操作写在里面即可。

其他#

关于 Lambda 表达式，我们发现上面的代码定义都是 auto 类型的，其实，除了 auto 类型，还可以是 function 类型的。

类模板 std::function ，定义于头文件 <functional>。std::function 能存储、复制及调用任何可调用目标——函数、Lambda 表达式或其他函数对象，还有指向成员函数指针和指向数据成员指针。

在 Lambda 表达式中，存储需要表明返回类型和参数，如下。

int main() {
	int a = 2, b = 1, c = 3;
	function<int()> it1 = [=, &a] () mutable {
		return a;
	};
	cout << it1() << '\n';
	function<void(int)> it2 = [&] (int a) {
		b = a * a;
		cout << b << '\n';
	};
	it2(a);
	function<ll(int, int, int)> it3 = [] (int x, int y, int z) {
		return 1ll * x * y * z;
	};
	cout << it3(a, b, c) << '\n';
	return 0;
}

就像这样，在尖括号内，先表明返回类型，再在小括号内表明参数类型，有几个参数就写几个，是 int 就写 int，是 double 就写 double。如果没有参数，也不能省略这个小括号。

此外，Lambda 表达式被定义后，只能在该封闭范围内使用，否则会报错。

void work() {
	int a = 2, b = 1, c = 3;
	cout << it3(a, b, c) << '\n';
}

int main() {
	int a = 2, b = 1, c = 3;
	function<int()> it1 = [=, &a] {
		return a;
	};
	cout << it1() << '\n';
	function<void(int)> it2 = [&] (int a) {
		b = a * a;
		cout << b << '\n';
	};
	it2(a);
	function<ll(int, int, int)> it3 = [] (int x, int y, int z) {
		return 1ll * x * y * z;
	};
	cout << it3(a, b, c) << '\n';
	work();
	return 0;
}

这份代码就报错了，因为 it3() 实在 main() 里面定义的，work() 里面不能访问到，同理，在 work() 里面定义的 Lambda 表达式，main() 里面也不能访问到，当然，你也可以定义全局都可以使用的 Lambda 表达式，像这样。其实定义在全局就跟函数几乎一样了。

function<ll(int, int, int)> it3 = [] (int x, int y, int z) {
	return 1ll * x * y * z;
};

void work() {
	int a = 2, b = 1, c = 3;
	cout << it3(a, b, c) << '\n';
}

int main() {
	int a = 2, b = 1, c = 3;
	function<int()> it1 = [=, &a] {
		return a;
	};
	cout << it1() << '\n';
	function<void(int)> it2 = [&] (int a) {
		b = a * a;
		cout << b << '\n';
	};
	it2(a);
	cout << it3(a, b, c) << '\n';
	work();
	return 0;
}

关于 Lambda 表达式的应用，可以代替一些函数，像 sort() 里面的自定义比较函数。但总归而言，它只是一种语法糖，只是可以让代码更可读并且自带 inline，更高版本的 C++ 中，Lambda 表达式的使用会更复杂，想了解更多的可以来这里。

参考资料#

• Lambda 表达式 - OI Wiki (oi-wiki.org)

• Lambda 表达式 (C++11 起) - cppreference.com