Lambda 表达式 (C++11 起)

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

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)
}

void f(const int*);
void g()
{
    const int N = 10;
    [=]{ 
        int arr[N]; // 非 ODR 式使用：指代 g 的 const int N
        f(&N); // ODR 式使用：导致 N 被（以复制）捕获
               // &N 是闭包对象的成员 N 的地址，而非 g 中的 N
    }();
}

void f3() {
    float x, &r = x;
    [=]
    { // x 与 r 不被捕获（出现于 decltype 的操作数中并不是 ODR 式使用）
        decltype(x) y1; // y1 拥有 float 类型
        decltype((x)) y2 = y1; // y2 拥有 float const& 类型，因为此 lambda
                               // 非 mutable 且 x 是左值
        decltype(r) r1 = y1;   // r1 拥有 float& 类型（不考虑变换）
        decltype((r)) r2 = y2; // r2 拥有 float const& 类型
    };
}

struct s2 {
  double ohseven = .007;
  auto f() { // 以下两个 lambda 的最接近外围函数
    return [this] { // 以引用捕获外围的 s2
      return [*this] { // 以复制捕获外围的 s2  (C++17)
          return ohseven; // OK
       }
     }();
  }
  auto g() {
     return []{ // 无捕获
         return [*this]{}; // 错误：*this 未被外层 lambda 表达式所捕获
      }();
   }
};

void f1(int i)
{
    int const N = 20;
    auto m1 = [=] {
            int const M = 30;
            auto m2 = [i] {
                    int x[N][M]; // N 与 M 未被 ODR 式使用 
                                 // （它们未被捕获是 OK 的）
                    x[0][0] = i; // i 被 m2 显式捕获
                                 // 并被 m1 隐式捕获
            };
    };
 
    struct s1 // f1() 中的局部类
    {
        int f;
        void work(int n) // 非静态成员函数
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m] {
                auto m4 = [&, j] { // 错误：j 未被 m3 所捕获
                        int x = n; // 错误：n 被 m4 隐式捕获
                                   // 但未被 m3 所捕获
                        x += m;    // ok：m 被 m4 捕获
                                   // 且为 m3 显式捕获
                        x += i;    // 错误：i 在可达作用域之外
                                   // （该作用域终于 work()）
                        x += f;    // ok：this 被 m4 隐式捕获
                                   // 且被 m3 显式捕获
                };
            };
        }
    };
}

class S {
  int x = 0;
  void f() {
    int i = 0;
//  auto l1 = [i, x]{ use(i, x); };    // 错误：x 非变量
    auto l2 = [i, x=x]{ use(i, x); };  // OK，复制捕获
    i = 1; x = 1; l2(); // 调用 use(0,0)
    auto l3 = [i, &x=x]{ use(i, x); }; // OK，引用捕获
    i = 2; x = 2; l3(); // 调用 use(1,2)
  }
};

class S {
  int x = 0;
  void f() {
    int i = 0;
    auto l1 = [=]{ use(i, x); }; // 捕获 i 的副本和 this 指针的副本
    i = 1; x = 1; l1(); // 调用 use(0,1)，如同 i 以复制而 x 以引用捕获
    auto l2 = [i, this]{ use(i, x); }; // 同上，令之为显式捕获
    i = 2; x = 2; l2(); // 调用 use(1,2)，如同 i 以复制而 x 以引用捕获
    auto l3 = [&]{ use(i, x); }; // 以引用捕获 i，并捕获 this 指针的副本
    i = 3; x = 2; l3(); // 调用 use(3,2)，如同 i 与 x 均以引用捕获
    auto l4 = [i, *this]{ use(i, x); }; // 制造 *this 的副本，包含 x 的副本
    i = 4; x = 4; l4(); // 调用 use(3,2)，如同 i 与 x 均以复制捕获
  }
};