C++ 中的Lambda表达式

傷城~ 2024-03-16 22:25 76阅读 0赞

> **Lambda 表达式**（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是**一个匿名函数，即没有函数名的函数**。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。  
> **闭包**就是能够读取其他函数内部变量的函数，**可以理解成“定义在一个函数内部的函数“**。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。  
> C++中的Lambda表达式从C++11开始引入，完整的声明如下：

[ 捕获 ] <模板形参> 约束(可选)
    ( 形参 ) lambda说明符 约束(可选) { 函数体 }

上面的 **<模板形参>**、**约束(可选)**、**lambda说明符** 属于较新的标准（c++17起），一般用的比较少，后面主要说明 **\[ 捕获 \]** 部分。  
**形参**、**返回类型**和**函数体** 与具名函数的定义一致，没有区别。

一个简单的Lambda表达式应用场景，代码如下：

#include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        vector<int> vec{ 3, 4 };
        //降序排序
        sort(vec.begin(), vec.end(), [](int a, int b) {return a > b; });
        for (size_t i = 0; i < vec.size(); i++)
        {
            cout << vec[i] << endl;
        }
    }

## 返回类型[\#][Link 1] ##

在**\{ 函数体 \}**前加**-> 返回类型**来指定返回类型。如果没有指定返回类型，那么闭包的 operator() 的返回类型从 return 语句推导，如同对于声明返回类型为 auto 的函数的推导一样。  
下面两个行代码是等价的：

//降序排序（不指定返回类型）
    sort(vec.begin(), vec.end(), [](int a, int b) {return a > b; });
    //降序排序（指定返回类型，没有返回值时可以指定为void类型）
    sort(vec.begin(), vec.end(), [](int a, int b) -> int {return a > b; });

## 捕获[\#][Link 2] ##

**捕获是一个含有零或更多个捕获符的逗号分隔列表**，可以**默认捕获符**开始。  
默认捕获符只有 **&**（以**引用**隐式捕获被使用的自动变量）和**=**（以\*\*复制隐式捕获被使用的自动变量）。

*  当默认捕获符是 & 时，后继的简单捕获符不能以 & 开始。

struct S2 { void f(int i); };
    void S2::f(int i)
    {
        [&]{};          // OK：默认以引用捕获
        [&, i]{};       // OK：以引用捕获，但 i 以值捕获
        [&, &i] {};     // 错误：以引用捕获为默认时的以引用捕获
        [&, this] {};   // OK：等价于 [&]
        [&, this, i]{}; // OK：等价于 [&, i]
    }

*  当默认捕获符是 = 时，后继的简单捕获符必须以 & 开始，或者为 \*this (C++17 起) 或 this (C++20 起)。

struct S2 { void f(int i); };
    void S2::f(int i)
    {
        [=]{};          // OK：默认以复制捕获
        [=, &i]{};      // OK：以复制捕获，但 i 以引用捕获
        [=, *this]{};   // C++17 前：错误：无效语法
                        // C++17 起：OK：以复制捕获外围的 S2
        [=, this] {};   // C++20 前：错误：= 为默认时的 this
                        // C++20 起：OK：同 [=]
    }

*  任何捕获符只可以出现一次，并且名字不能与形参相同：

struct S2 { void f(int i); };
    void S2::f(int i)
    {
        [i, i] {};        // 错误：i 重复
        [this, *this] {}; // 错误："this" 重复（C++17）
     
        [i] (int i) {};   // 错误：形参和捕获的名字相同
    }

上面出现的两个特殊的捕获符作用如下：

*  **this**：当前对象的简单的以**引用捕获**
 *  **\* this**：当前对象的简单的以**复制捕获**

## 原理[\#][Link 3] ##

先建一个简单的Lambda表达式示例，代码如下：

#include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        int sum = 0;
        int std = 1;
        vector<int> vec{ 3, 4 };    
        for_each(vec.begin(), vec.end(), [&sum,std](int x) {sum += (x+std); });
        cout << sum << endl;
    }

然后在[C++ Insights][C_ Insights]中查看Lambda表达式展开后的代码，完整代码如下：

#include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
      int sum = 0;
      int std = 1;
      std::vector<int, std::allocator<int> > vec = std::vector<int, std::allocator<int> >{std::initializer_list<int>{3, 4}, std::allocator<int>()};
        
      class __lambda_11_38
      {
        public: 
        inline void operator()(int x) const
        {
          sum = sum + (x + std);
        }
        
        private: 
        int & sum;
        int std;
        public: 
        // inline /*constexpr */ __lambda_11_38(__lambda_11_38 &&) noexcept = default;
        __lambda_11_38(int & _sum, int & _std)
        : sum{_sum}
        , std{_std}
        {}
        
      };
      
      std::for_each(__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >(vec.begin()), __gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >(vec.end()), __lambda_11_38(__lambda_11_38{sum, std}));
      std::cout.operator<<(sum).operator<<(std::endl);
      return 0;
    }

可以看到Lambda表达式展开为类**\_\_lambda\_11\_38**，捕获的外部变量赋值到类的成员变量上，引用捕获以指针赋值，复制捕获直接拷贝。  
类**\_\_lambda\_11\_38**重载了操作符**()**，它其实就是一个仿函数。

## Lambda回调[\#][Link 4] ##

在C++中可以使用模板、函数指针、抽象类和Lambda实现回调的效果，此处主要说明如何使用**Lambda**和**function**在同步线程中实现回调的效果。  
类模板 **std::function 是通用多态函数包装器**，实例**能存储、复制及调用任何可复制构造 (CopyConstructible) 的可调用 (Callable) 目标**——函数、 lambda 表达式、 bind 表达式或其他函数对象，还有指向成员函数指针和指向数据成员指针。  
若 std::function 不含目标，则称它为空，调用空 std::function 的目标导致抛出 std::bad\_function\_call 异常。

一个简单的Lambda回调，类似于C\#中的事件，代码如下：

#include <iostream>
    #include <vector>
    #include <algorithm>
    #include <functional>
    using namespace std;
    
    class Test
    {
    public:
        function<void(const int& num)> Func;
        void SetNum(int num) 
        {
            nowNum = num;
            OnFunc(nowNum);
        }
    private:
        int nowNum;
        void OnFunc(const int& num)
        {
            if (Func)
            {
                // 在此处回调
                Func(num);		
            }
        }
    };
    int main()
    {
        Test test;
        test.Func = [](const int& num)
        {
            cout << num << endl;
        };
        test.SetNum(100);
    }

## 参考[\#][Link 5] ##

*  [Lambda 表达式][Lambda]
 *  [std::function][std_function]
 *  [C++11之lambda回调设置与应用][C_11_lambda]

[Link 1]: https://www.cnblogs.com/timefiles/p/CppLambda.html#%E8%BF%94%E5%9B%9E%E7%B1%BB%E5%9E%8B
[Link 2]: https://www.cnblogs.com/timefiles/p/CppLambda.html#%E6%8D%95%E8%8E%B7
[Link 3]: https://www.cnblogs.com/timefiles/p/CppLambda.html#%E5%8E%9F%E7%90%86
[C_ Insights]: https://cppinsights.io/
[Link 4]: https://www.cnblogs.com/timefiles/p/CppLambda.html#lambda%E5%9B%9E%E8%B0%83
[Link 5]: https://www.cnblogs.com/timefiles/p/CppLambda.html#%E5%8F%82%E8%80%83
[Lambda]: https://zh.cppreference.com/w/cpp/language/lambda#Lambda_.E6.8D.95.E8.8E.B7
[std_function]: https://zh.cppreference.com/w/cpp/utility/functional/function
[C_11_lambda]: https://blog.csdn.net/King_weng/article/details/115079012