# lambda表达式

匿名函数是很多高级语言都支持的概念，如lisp语言在1958年首先采用匿名函数。匿名函数有函数体，但没有函数名。C++11中引入了lambda表达式。利用`lambda`表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。但是从本质上来讲，`lambda`表达式只是一种语法糖，因为所有其能完成的工作都可以用其它稍微复杂的代码来实现。但是它简便的语法却给`C++`带来了深远的影响。如果从广义上说，`lamdba`表达式产生的是函数对象。

> 相同类似功能我们也可以使用**函数对象**或者**函数指针**实现：函数对象能维护状态，但语法开销大，而函数指针语法开销小，却没法保存范围内的状态。lambda表达式正是结合了两者的优点。

## :pencil2: 1、Lambda表达式

### :pen\_fountain: 1.1、声明Lambda表达式

```cpp
// 完整语法
[capture list] (params list) mutable(optional) constexpr(optional)(c++17) exception attribute -> return type { function body };

// 可选的简化语法
[capture list] (params list) -> return type {function body};  //1
[capture list] (params list) {function body};		//2
[capture list] {function body};		//3
```

* capture list：捕获外部变量列表，不能省略；
* params list：形参列表，可以省略（但是后面必须紧跟函数体）；
* mutable指示符： 可选，将`lambda`表达式标记为`mutable`后，函数体就可以修改传值方式捕获的变量；
* constexpr：可选，C++17，可以指定`lambda`表达式是一个常量函数；
* exception：异常设定， 可选，指定`lambda`表达式可以抛出的异常；
* attribute：可选，指定`lambda`表达式的特性；
* return type：返回类型
* function body：函数体

标号1. 函数声明了一个const类型的表达式，此声明不可改变capture list中的捕获的值。

标号2. 函数省略了返回值，此时如果function body内含有return语句，则按return语句返回类型决定返回值类型，若无则返回值为void类型。

标号3. 函数无参数列表，意味无参函数。

```cpp
vector<int> vec{1,0,9,5,3,3,7,8,2};

sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });  
```

### :pen\_fountain: 1.2、捕获外部变量

`lambda`表达式最前面的方括号的意义何在？其实这是`lambda`表达式一个很Hong要的功能，就是闭包。这里我们先讲一下`lambda`表达式的大致原理：每当你定义一个`lambda`表达式后，编译器会自动生成一个匿名类（这个类当然重载了`()`运算符），我们称为闭包类型（closure type）。那么在运行时，这个`lambda`表达式就会返回一个**匿名的闭包实例**，其实一个右值。所以，我们上面的`lambda`表达式的结果就是一个个闭包。闭包的一个强大之处是其可以通过传值或者引用的方式捕捉**其封装作用域内的变量**，前面的方括号就是用来定义捕捉模式以及变量，我们又将其称为`lambda`捕捉块。

Lambda表达式可以捕获外面变量，但需要我们提供一个谓词函数（\[capture list]在声明表达式最前）。类似参数传递方式：值传递、引入传递、指针传递。在Lambda表达式中，外部变量捕获方式也类似：**值捕获、引用捕获、隐式捕获**。

#### 值捕获

```cpp
int a = 123;
auto f = [a] { cout << a << endl; }; 
f(); // 输出：123
a = 321;
f(); // 输出：123
```

值捕获和参数传递中的**值传递**类似，被捕获的值在Lambda表达式创建时通过**值拷贝**的方式传入，类中会相应添加对应类型的非静态数据成员。在运行时，会用复制的值初始化这些成员变量，从而生成闭包。因此**Lambda表达式函数体中不能修改该外部变量的值**； 因为函数调用运算符的重载方法是`const`属性的。同样，函数体外对于值的修改也不会改变被捕获的值。 想改动传值方式捕获的值，那么就要使用`mutable`。

```cpp
auto add_x = [x](int a) mutable { x *= 2; return a + x; };  // 复制捕捉x
    
cout << add_x(10) << endl; // 输出：30
```

&#x20;因为一旦将`lambda`表达式标记为`mutable`，那么实现的函数调用运算符是非const属性的。

#### 引用捕获

```cpp
int a = 123;
auto f = [&a] { cout << a << endl; }; 
a = 321;
f(); // 输出：321
```

引用捕获的变量使用的实际上就是该引用所绑定的对象，因此引用对象的改变会改变函数体内对该对象的引用的值。 对于引用捕获方式，无论是否标记`mutable`，都可以在`lambda`表达式中修改捕获的值。

#### 隐式捕获

隐式捕获有两种方式，分别是\
\[=]：以值补获的方式捕获外部**所有变量**\
\[&]：表示以引用捕获的方式捕获外部**所有变量**。

```cpp
int a = 123, b=321;
auto df = [=] { cout << a << b << endl; };    // 值捕获
auto rf = [&] { cout << a << b << endl; };    // 引用捕获
```

#### 其他捕获方式

| 捕获外部变量形式       |                          |
| -------------- | ------------------------ |
| \[ ]           | 不捕获任何变量（无参函数）            |
| \[变量1,&变量2, …] | 值(引用)形式捕获指定的多个外部变量       |
| \[this]        | 值捕获this指针                |
| \[=, \&x]      | 变量x以引用形式捕获，其余变量以传值形式捕获   |
| \[\*this]      | 通过传值方式捕获当前对象             |
| \[&, x]        | 默认以引用捕获所有变量，但是x是例外，通过值捕获 |

> 既然只使用一次，那直接写全代码不久醒了，为啥要函数呢？——因为lambda可以捕获局部变量

在上面的捕获方式中，注意最好不要使用`[=]`和`[&]`默认捕获所有变量。首先说默认引用捕获所有变量，你有很大可能会出现悬挂引用（Dangling references），因为引用捕获不会延长引用的变量的声明周期：

```cpp
std::function<int(int)> add_x(int x)
{
    return [&](int a) { return x + a; };
}
```

因为参数`x`仅是一个临时变量，函数调用后就被销毁，但是返回的`lambda`表达式却引用了该变量，但调用这个表达式时，引用的是一个垃圾值，所以会产生没有意义的结果。如果通过传值的方式来解决上面的问题：

```cpp
std::function<int(int)> add_x(int x)
{
    return [=](int a) { return x + a; };
}
```

使用默认传值方式可以避免悬挂引用问题。但是采用默认值捕获所有变量仍然有风险，看下面的例子：

```cpp
class Filter
{
public:
    Filter(int divisorVal) : divisor(divisorVal){}

    std::function<bool(int)> getFilter() 
    {
        return [=](int value) {return value % divisor == 0; };
    }

private:
    int divisor;
};
```

这个类中有一个成员方法，可以返回一个`lambda`表达式，这个表达式使用了类的数据成员`divisor`。而且采用默认值方式捕捉所有变量。你可能认为这个`lambda`表达式也捕捉了`divisor`的一份副本，但是实际上大错特错。问题出现在哪里呢？因为数据成员`divisor`对`lambda`表达式并不可见，你可以用下面的代码验证：

```cpp
// 类的方法，下面无法编译，因为divisor并不在lambda捕捉的范围
std::function<bool(int)> getFilter() 
{
    return [divisor](int value) {return value % divisor == 0; };
}
```

那么原来的代码为什么能够捕捉到呢？仔细想想，原来每个非静态方法都有一个`this`指针变量，利用`this`指针，你可以接近任何成员变量，所以`lambda`表达式实际上捕捉的是`this`指针的副本，所以原来的代码等价于：

```cpp
std::function<bool(int)> getFilter() 
{
    return [this](int value) {return value % this->divisor == 0; };
}
```

尽管还是以值方式捕获，但是捕获的是指针，其实相当于以引用的方式捕获了当前类对象，所以`lambda`表达式的闭包与一个类对象绑定在一起了，这也很危险，因为你仍然有可能在类对象析构后使用这个`lambda`表达式，那么类似“悬挂引用”的问题也会产生。所以，采用默认值捕捉所有变量仍然是不安全的，主要是由于指针变量的复制，实际上还是按引用传值。

### :pen\_fountain: 1.3、参数

* 参数列表中不能有默认参数
* 不支持可变参数
* 所有参数必须有参数名

### :pen\_fountain: 1.4、返回类型

单一的return语句可以推断返回类型；多语句则默认返回void，否则报错，应指定返回类型。

```cpp
// 正确，单一return语句
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) { 
    return i<0? -i; i;
    }
);
// 错误。不能推断返回类型
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) { 
        if (I<0) return -i;
        else return i;
    }
);
// 正确，尾置返回类型
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) ->int{ 
        if (I<0) 
            return -i;
        else 
            return i;
    }
);
```

### :pen\_fountain: 1.5、赋值

可以使用auto 和function 接受lambda表达式的返回：

```cpp
int x = 8, y = 9;
auto add = [](int a, int b) { return a + b; };
std::function<int(int, int)> Add = [=](int a, int b) { return a + b; };

cout << "add: " << add(x, y) << endl; // 17
cout << "Add: " << Add(x, y) << endl; // 17
```

lambda表达式产生的类不含有默认构造函数、赋值运算符、默认析构函数。至于闭包类中是否有对应成员，`C++`标准中给出的答案是：不清楚的，看来与具体实现有关。还有一点要注意：`lambda`表达式是不能被赋值的：

```cpp
auto a = [] { cout << "A" << endl; };
auto b = [] { cout << "B" << endl; };

a = b;   // 非法，lambda无法赋值
auto c = a;   // 合法，生成一个副本
```

因为禁用了赋值操作符：

```cpp
ClosureType& operator=(const ClosureType&) = delete;
```

但是没有禁用复制构造函数，所以可以用一个`lambda`表达式去初始化另外一个`lambda`表达式而产生副本。并且`lambda`表达式也可以赋值给相对应的函数指针，这也使得你完全可以把`lambda`表达式看成对应**函数类型的指针**。

### :pen\_fountain: 1.6、新特性

&#x20;在`C++14`中，`lambda`又得到了增强，一个是泛型`lambda`表达式，一个是`lambda`可以捕捉表达式。

#### lambda捕捉表达式

`lambda`表达式可以按复制或者引用捕获在其作用域范围内的变量。而有时候，我们希望捕捉不在其作用域范围内的变量，而且最重要的是我们希望捕捉右值。所以`C++14`中引入了表达式捕捉，其允许用任何类型的表达式初始化捕捉的变量：

```cpp
// 利用表达式捕获，可以更灵活地处理作用域内的变量
int x = 4;
auto y = [&r = x, x = x + 1] { r += 2; return x * x; }();
// 此时 x 更新为6，y 为25

// 直接用字面值初始化变量
auto z = [str = "string"]{ return str; }();
// 此时z是const char* 类型，存储字符串 string
```

可以看到捕捉表达式扩大了`lambda`表达式的捕捉能力，有时候你可以用`std::move`初始化变量。这对不能复制只能移动的对象很重要，比如`std::unique_ptr`，因为其不支持复制操作，你无法以值方式捕捉到它。但是利用`lambda`捕捉表达式，可以通过移动来捕捉它：

```cpp
auto myPi = std::make_unique<double>(3.1415);

auto circle_area = [pi = std::move(myPi)](double r) { return *pi * r * r; };
cout << circle_area(1.0) << endl; // 3.1415
```

&#x20;其实用表达式初始化捕捉变量，与使用`auto`声明一个变量的机理是类似的。

#### 泛型lambda表达式

从`C++14`开始，`lambda`表达式支持泛型：其参数可以使用自动推断类型的功能，而不需要显示地声明具体类型。这就如同函数模板一样，参数要使用类型自动推断功能，只需要将其类型指定为`auto`，类型推断规则与函数模板一样。这里给出一个简单例子：

```cpp
auto add = [](auto x, auto y) { return x + y; };

int x = add(2, 3);   // 5
double y = add(2.5, 3.5);  // 6.0
```

### :pen\_fountain: 1.7、Lambda与`STL`

`lambda`表达式可以赋值给对应类型的函数指针。但是使用函数指针貌似并不是那么方便。所以`STL`定义在`<functional>`头文件提供了一个多态的函数对象封装`std::function`，其类似于函数指针。它可以绑定任何类函数对象，只要参数与返回类型相同。如下面的返回一个bool且接收两个int的函数包装器：

```cpp
std::function<bool(int, int)> wrapper = [](int x, int y) { return x < y; };
```

而`lambda`表达式一个更重要的应用是其可以用于函数的参数，通过这种方式可以实现回调函数。其实，最常用的是在`STL`算法中，比如你要统计一个数组中满足特定条件的元素数量，通过`lambda`表达式给出条件，传递给`count_if`函数：

```cpp
int value = 3;
vector<int> v {1, 3, 5, 2, 6, 10};

int count = std::count_if(v.beigin(), v.end(), [value](int x) { return x > value; });
```

再比如你想生成斐波那契数列，然后保存在数组中，此时你可以使用`generate`函数，并辅助`lambda`表达式：

```cpp
vector<int> v(10);
int a = 0;
int b = 1;

std::generate(v.begin(), v.end(), [&a, &b] { int value = b; b = b + a; a = value; return value; });
// 此时v {1, 1, 2, 3, 5, 8, 13, 21, 34, 55}
```

此外，`lambda`表达式还用于对象的排序准则：

```cpp
class Person
{
public:
    Person(const string& first, const string& last):
        firstName(first), lastName(last) {}

    Person() = default;

    string first() const { return firstName; }
    string last() const { return lastName; }
private:
    string firstName;
    string lastName;
};

int main()
{
    vector<Person> vp;
    // 添加Person信息
    ...
    // 按照姓名排序
    std::sort(vp.begin(), vp.end(), [](const Person& p1, const Person& p2)
    { return p1.last() < p2.last() || (p1.last() == p2.last() && p1.first() < p2.first()); });

    return 0;
}
```

总之，对于大部分`STL`算法，可以非常灵活地搭配`lambda`表达式来实现想要的效果。

## :pencil2: 2、Lambda与递归

对于一个求自然数1-N和的问题，我们很容易写出以下递归公式：

```cpp
f(n) = n == 1 ? 1 : n + f(n - 1);
```

若想使用C++lambda表达式实现上述过程，我们很容易将其改写为以下代码：

```cpp
const auto& f = [](const int& n) {
	return n == 1 ? 1 : n + f(n - 1);
};
```

发现编译无法通过。

### :pen\_fountain: 2.1、使用std::function

std::function可以把lambda包装起来，相当于赋予了其一个函数名，在通过引用捕获并实现递归调用，实现如下：

```cpp
const auto& sum = [](const int& n) {
		std::function<int(const int&)> s;
		s = [&](const int& n) {
			  return n == 1 ? 1 : n + s(n - 1);
		};
		return s(n);
};

std::cout << sum(100);
```

### :pen\_fountain: 2.2、将lambda作为参数

```cpp
const auto& sum = [](const int& n) {
		const auto& s = [&](auto&& self, const int& x) -> int {
			  return x == 1 ? 1 : x + self(self, x - 1);
		};
		return s(s, n);
};

std::cout << sum(100);
```

### :pen\_fountain: 2.3、函数指针

{% tabs %}
{% tab title="C++14" %}

```cpp
auto sum = std::make_shared<std::unique_ptr< std::function<int(int)> >>();
*sum = std::make_unique<std::function<int(int)>>(
    [=](int n) {
        return n == 1 ? 1 : n + (**sum)(n - 1);
    }
);

std::cout << (**sum)(100);
```

{% endtab %}

{% tab title="C++11" %}

```cpp
auto sum = std::shared_ptr<std::unique_ptr< std::function<int(int)> >>
    (new std::unique_ptr< std::function<int(int)> >());
*sum = std::unique_ptr<std::function<int(int)>>(
    new std::function<int(int)>(
        [=](int n) {
            return n == 1 ? 1 : n + (**sum)(n - 1);
        }
    )
);

std::cout << (**sum)(100);
```

{% endtab %}
{% endtabs %}

### :pen\_fountain: 2.4、使用Y组合子

构造一个Y组合子如下：

```cpp
const auto& y = [](const auto& f) {
	  return [&](const auto& x) {
		    return x(x);
	  }([&](const auto& x) -> std::function<int(int)> {
		    return f([&](const int& n) {
			      return x(x)(n);
		    });
	  });
};
```

再实现一个求和函数的高阶函数，然后连接即可：

```cpp
const auto& sum = [](const auto& f) {
		return [=](const int& n) {
			  return n == 1 ? 1 : n + f(n - 1);
		};
};

std::cout << y(sum)(100);
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mqjyl2012.gitbook.io/algorithm/c-cpp/advanced-c++/lambda.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.