[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {
	// 函数体
}

语法规则：lambda表达式可以看成是一般函数的函数名被略去，返回值使用了一个 -> 的形式表示。唯一与普通函数不同的是增加了“捕获列表”。

// lambda_test lambda_test.cc
#include <iostream>

using namespace std;

void test01()
{
	cout << "test01" << endl;
	auto Add = [](int a, int b) -> int {
		return a + b;
	};

	cout << Add(1, 2) << endl;
}

int main(int argc,char **argv)
{
	test01();

	return 0;
}

g++ -o lambda_test lambda_test.cc -std=c++11

一般情况下，编译器可以自动推断出lambda表达式的返回类型，所以我们可以不指定返回类型，即：

// lambda_test lambda_test.cc
#include <iostream>

using namespace std;

void test02()
{
	cout << "test02" << endl;
	auto Add = [](int a, int b){
		return a + b;
	};

	cout << Add(1, 2) << endl;
}

int main(int argc,char **argv)
{
	//test01();
	test02();
	return 0;
}

但是如果函数体内有多个return语句时，编译器无法自动推断出返回类型，此时必须指定返回类型。

有时候，需要在匿名函数内使用外部变量，所以用捕获列表来传递参数。根据传递参数的行为，捕获列表可分为以下几种：

与参数传值类似，值捕获的前提是变量可以拷贝，不同之处则在于，

被捕获的变量在 lambda表达式被创建时拷贝

// lambda_test lambda_test.cc
#include <iostream>

using namespace std;

void test03()
{
	cout << "test03" << endl;
	int c = 20;
	int d = 30;
	auto Add = [c,d](int a, int b) {
		cout << "d = "<< d << endl;
		return c;
	};

	d = 10; // 在这里修改 d 的值，会改变 Add里的 d 值吗？

	cout << Add(1, 2) << endl;
}


int main(int argc,char **argv)
{

	//test01();
	//test02();
	
	test03();
	
	return 0;
}

与引用传参类似，引用捕获保存的是引用，值会发生变化。

#include <iostream>

using namespace std;
void test04()
{
	cout << "test04" << endl;
	int c = 20;
	int d = 30;
	auto Add = [c, &d](int a, int b) {
		cout << "c = " << c << endl;
		cout << "d = " << d << endl;
		return c;
	};

	d = 10;//在这里修改d的值，会改变Add里的d值吗？

	cout << Add(1, 2) << endl;
}


int main(int argc,char **argv)
{

	//test01();
	//test02();
	//test03();
	test04();

	return 0;
}

手动书写捕获列表有时候是非常复杂的，这种机械性的工作可以交给编译器来处理，这时候可以在捕获列表中写一个 

。编译器会将外部变量全部捕获。

#include <iostream>

using namespace std;

void test05()
{
	cout << "test05" << endl;
	int c = 20;
	int d = 30;
	auto Add = [&](int a, int b) {
		cout << "c = " << c << endl;
		cout << "d = " << d << endl;
		return c;
	};

	d = 10;//在这里修改d的值，会改变Add里的d值吗？

	cout << Add(1, 2) << endl;
}

void test06()
{
	cout << "test06" << endl;
	int c = 20;
	int d = 30;
	auto Add = [=](int a, int b) {
		cout << "c = " << c << endl;
		cout << "d = " << d << endl;
		return c;
	};

	d = 10;//在这里修改d的值，会改变Add里的d值吗？

	cout << Add(1, 2) << endl;
}

int main(int argc,char **argv)
{

	//test01();
	//test02();
	//test03();
	test05();
	test06();

	return 0;
}

$ ./lambda_test
test05
c = 20
d = 10
20
test06
c = 20
d = 30
20

捕获列表’[]'中为空，表示Lambda不能使用所在函数中的变量。

void test07()
{
	cout << "test07" << endl;
	int c = 20;
	int d = 30;
	auto Add = [](int a, int b) {
		cout << "c = " << c << endl; // 编译报错
		cout << "d = " << d << endl; // 编译报错
		return c;					 // 编译报错
	};

	d = 10;

	cout << Add(1, 2) << endl;
}

lambda_test.cc:95:14: note: the lambda has no capture-default
  auto Add = [](int a, int b) {
              ^
lambda_test.cc:93:6: note: ‘int c’ declared here
  int c = 20;
      ^
lambda_test.cc:97:21: error: ‘d’ is not captured
   cout << "d = " << d << endl;

上面提到的值捕获、引用捕获都是已经在外层作用域声明的变量，因此这些捕获方式捕获的均为左值，而不能捕获右值。

C++14之后支持捕获右值，允许捕获的成员用任意的表达式进行初始化，被声明的捕获变量类型会根据表达式进行判断，判断方式与使用 auto 本质上是相同的：

#include <iostream>
#include <memory>
using namespace std;

void test08()
{
	cout << "test08" << endl;
	
	auto important = make_unique<int>(1);
	auto Add = [v1 = 1, v2 = std::move(important)](int a, int b)->int{
	
		return a + b + v1 + (*v2);
	};

	cout << Add(1, 2) << endl;
}

int main(int argc,char **argv)
{

	test08();

	return 0;
}

在C++14之前，lambda表示的形参只能指定具体的类型，没法泛型化。从 C++14 开始， Lambda 函数的形式参数可以使用 auto关键字来产生意义上的泛型。

简单点说，就是通过auto使lambda自适应参数类型：

#include <iostream>

using namespace std;

void test09()
{
	cout << "test09" << endl;
	auto Add = [](auto a, auto b) {
		return a + b;
	};

	cout << Add(1, 2) << endl;
	cout << Add(1.1, 2.2) << endl;
}

int main(int argc,char **argv)
{

	test09();

	return 0;
}

（1）采用值捕获的方式，lambda不能修改其值，如果想要修改，使用mutable修饰。

（2）采用引用捕获的方式，lambda可以直接修改其值。

#include <iostream>

using namespace std;

void test10()
{
	cout << "test10" << endl;
	int v = 10;
	// 值捕获方式，使用mutable修饰，可以改变捕获的变量值
	auto tes = [v]() mutable {
		return ++v;
	};

	v = 5;
	auto a = tes();// a=11;
	cout << a << endl;
}

void test11()
{
	cout << "test11" << endl;
	int v = 10;
	auto Add = [&v]{
		return v++;
	};
	v = 6;
	cout << Add() << endl;
}

int main(int argc,char **argv)
{

	test10();
	test11();

	return 0;
}

#include <iostream>

using namespace std;

void test12()
{
	cout << "test12" << endl;
	
	int c = 12;
	int d = 30;
	int e = 30;
	// auto Add = [&, d, e](int a, int b)
	auto Add = [=, &c](int a, int b) -> int {
		c = a;
		cout << "d=" << d << ", e=" << e << endl;
		return c;
	};
	d = 20;
	cout << Add(1, 2) << endl;
	cout << "c:" << c << endl;
}

int main(int argc,char **argv)
{

	test12();

	return 0;
}

一文读懂C++中的Lambda函数：简洁、高效、灵活

C++ Lambda函数，以其简洁、高效和灵活的特性，正逐渐成为现代C++开发不可或缺的一部分。本文将深入剖析Lambda函数的语法、捕获机制、应用场景和底层原理，助你快速掌握这一强大工具。通过实例演示，你将学会如何利用Lambda函数简化代码、提高效率，并在STL算法、异步编程等领域灵活运用，让C++代码更加优雅和强大。

编程语言

编译器

4位行业大咖将分享DeepSeek × 技术创作者：10倍速构建专业影响力讲座，助你抢占AI红利窗口！点击报名到场/直播预约：<a href="https://cloud.tencent.com/developer/salon/salon-2328" target="_blank">https://cloud.tencent.com/developer/salon/salon-2328</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/3b8f3fb01c22a358ef9f87c7ffbddb3b.jpg"/>

一文读懂C++中的Lambda函数：简洁、高效、灵活

一文读懂C++中的Lambda函数：简洁、高效、灵活

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐