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 は g のではなくクロージャオブジェクトのメンバ N のアドレスです。
    }();
}

void f3() {
    float x, &r = x;
    [=]
    { // x も r もキャプチャされません (decltype の被演算子内の出現は ODR 使用ではありません)
        decltype(x) y1; // y1 は float 型です。
        decltype((x)) y2 = y1; // このラムダが mutable でなく、 x が左辺値であるため、
                               // y2 は float const& 型です。
        decltype(r) r1 = y1;   // r1 は float& 型です (変換は考慮されません)。
        decltype((r)) r2 = y2; // r2 は float const& 型です。
    };
}

struct s2 {
  double ohseven = .007;
  auto f() { // 以下の2つのラムダに対する最も近い囲っている関数。
    return [this] { // 囲っている s2 を参照によってキャプチャします。
      return [*this] { // 囲っている s2 をコピーによってキャプチャします (C++17)。
          return ohseven; // OK。
       }
     }();
  }
  auto g() {
     return []{ // 何もキャプチャしません。
         return [*this]{}; // エラー、 *this が外側のラムダ式によってキャプチャされていません。
      }();
   }
};

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(); // コピーによる i および参照による x であるかのように、 use(0, 1) を呼びます。
    auto l2 = [i, this]{ use(i, x); }; // 同上ですが、明示的に行います。
    i = 2; x = 2; l2(); // コピーによる i および参照による x であるかのように、 use(1, 2) を呼びます。
    auto l3 = [&]{ use(i, x); }; // 参照による i および this ポインタのコピーをキャプチャします。
    i = 3; x = 2; l3(); // どちらも参照による i および x であるかのように、 use(3, 2) を呼びます。
    auto l4 = [i, *this]{ use(i, x); }; // *this のコピー (x のコピーを含む) を作成します。
    i = 4; x = 4; l4(); // どちらもコピーによる i および x であるかのように、 use(3, 2) を呼びます。
  }
};