Lambda expressions (since C++11)

closure （スコープ内の変数を捕捉可能な無名関数オブジェクト）を構築します。

構文

明示的なテンプレートパラメータリストを持たないラムダ式（非ジェネリックの可能性あり）

明示的なテンプレートパラメータリストを持つラムダ式 (常にジェネリック) (C++20以降)

説明

変数 __func__ は body の先頭で暗黙的に定義され、その意味は こちら で説明されている通りです。

クロージャ型

ラムダ式は、一意の無名非 union 非 aggregate クラス型のprvalue式であり、 クロージャ型 として知られています。この型は（ ADL の目的で）ラムダ式を含む最小のブロックスコープ、クラススコープ、または名前空間スコープで宣言されます。

クロージャ型は以下のメンバを持ち、これらは 明示的なインスタンス化 、 明示的な特殊化 、または (C++14以降) friend宣言 で名前を指定することはできません：

// generic lambda, operator() is a template with two parameters
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14); // OK
// generic lambda, operator() is a template with one parameter
auto vglambda = [](auto printer)
{
    return [=](auto&&... ts) // generic lambda, ts is a parameter pack
    { 
        printer(std::forward<decltype(ts)>(ts)...);
        // nullary lambda (takes no parameters):
        return [=] { printer(ts...); };
    };
{
auto p = vglambda([](auto v1, auto v2, auto v3)
{
    std::cout << v1 << v2 << v3;
});
auto q = p(1, 'a', 3.14); // outputs 1a3.14
q();                      // outputs 1a3.14

// generic lambda, operator() is a template with two parameters
auto glambda = []<class T>(T a, auto&& b) { return a < b; };
// generic lambda, operator() is a template with one parameter pack
auto f = []<typename... Ts>(Ts&&... ts)
{
    return foo(std::forward<Ts>(ts)...);
};

struct X
{
    int x, y;
    int operator()(int);
    void f()
    {
        // 以下のラムダのコンテキストはメンバー関数 X::f です
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this の型は X*
        };
    }
};

1. ↑ 関数の戻り値型推論はC++14で導入されていますが、その規則はC++11のラムダ戻り値型推論でも利用可能です。

void f1(int (*)(int)) {}
void f2(char (*)(int)) {}
void h(int (*)(int)) {}  // #1
void h(char (*)(int)) {} // #2
auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // error: not convertible
h(glambda);  // OK: calls #1 since #2 is not convertible
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK

auto Fwd = [](int(*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return a; };
static_assert(Fwd(C, 3) == 3);  // OK
auto NC = [](auto a) { static int s; return a; };
static_assert(Fwd(NC, 3) == 3); // error: no specialization can be
                                // constexpr because of static s

Lambdaキャプチャ

captures は、ラムダ関数本体の内部からアクセス可能な外部変数を定義します。その構文は以下のように定義されます：

capture の構文は以下のように定義されます：

capture-default が & の場合、後続の単純キャプチャは & で始まってはなりません。

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK: 参照によるデフォルトキャプチャ
    [&, i] {};       // OK: 参照によるキャプチャ、ただしiはコピーでキャプチャ
    [&, &i] {};      // エラー: 参照がデフォルトの場合の参照キャプチャ
    [&, this] {};    // OK、[&]と同等
    [&, this, i] {}; // OK、[&, i]と同等
}

capture-default が = の場合、後続の単純キャプチャは & で始まる必要があります 、または *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) {};   // エラー: パラメータとキャプチャが同じ名前
}

ラムダ式は、変数をキャプチャしなくてもその変数を使用できます（その変数が

• 非ローカル変数、または静的もしくはスレッドローカルな ストレージ期間 を持つ場合（この場合、変数はキャプチャできません）、または
• 定数式 で初期化された参照である場合。

ラムダ式は、変数が以下の場合にキャプチャせずにその値を読み取ることができます

• const非volatileの整数型または列挙型を持ち、かつ 定数式 で初期化されている場合、または
• constexprであり、かつmutableメンバーを持たない場合。

現在のオブジェクト ( * this ) は、キャプチャデフォルトが存在する場合、暗黙的にキャプチャすることができます。暗黙的にキャプチャされる場合、キャプチャデフォルトが = であっても、常に参照によってキャプチャされます。 キャプチャデフォルトが = の場合の * this の暗黙的キャプチャは非推奨です。 (C++20以降)

以下のいずれかの条件を満たすラムダ式のみが、初期化子なしの capture-default または capture を持つことができます：

• その最も内側の 囲むスコープ は ブロックスコープ である。
• それが デフォルトメンバ初期化子 内に現れ、その最も内側の囲むスコープは対応する クラススコープ である。

このようなラムダ式に対して、 reaching scope は、最も内側の外側の関数（とそのパラメータ）を含む、外側のスコープの集合として定義されます。これには、ネストされたブロックスコープと、このラムダがネストされている場合は外側のラムダのスコープも含まれます。

初期化子なしのキャプチャ（ this キャプチャを除く）における identifier は、ラムダの reaching scope 内で通常の unqualified name lookup を用いて検索されます。検索結果は、reaching scope で宣言された自動記憶域期間を持つ variable であるか、 対応する変数がこの要件を満たす structured binding (C++20以降) でなければなりません。このエンティティは explicitly captured されます。

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // updates ::x to 6 and initializes y to 25.

captures が capture-default を持ち、かつ囲んでいるオブジェクト（ this または * this ）を明示的にキャプチャしておらず、あるいはラムダ本体で odr-usable な自動変数 、または対応する変数がアトミック記憶域期間を持つ structured binding (C++20以降) を明示的にキャプチャしていない場合、そのエンティティが式内の potentially-evaluated な式で使用されているとき（非静的クラスメンバの使用前に暗黙の this - > が追加される場合を含む）、そのエンティティを 暗黙的に キャプチャする。

暗黙的なキャプチャを決定する目的において、 typeid はそのオペランドを未評価式にしないものと見なされます。

void f(int, const int (&)[2] = {}) {}   // #1
void f(const int&, const int (&)[1]) {} // #2
struct NoncopyableLiteralType
{
    constexpr explicit NoncopyableLiteralType(int n) : n_(n) {}
    NoncopyableLiteralType(const NoncopyableLiteralType&) = delete;
    int n_;
};
void test()
{
    const int x = 17;
    auto l0 = []{ f(x); };           // OK: #1を呼び出し、xをキャプチャしない
    auto g0 = [](auto a) { f(x); };  // 同上
    auto l1 = [=]{ f(x); };          // OK: xをキャプチャし（P0588R1以降）、#1を呼び出す
                                     // キャプチャは最適化により除去可能
    auto g1 = [=](auto a) { f(x); }; // 同上
    auto ltid = [=]{ typeid(x); };   // OK: xをキャプチャする（P0588R1以降）
                                     // xが未評価であっても
                                     // キャプチャは最適化により除去可能
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: 依存式であるため、xをキャプチャする
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // a + xが未評価オペランドかどうかにかかわらず
                        // xをキャプチャする
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: wはodr使用されず、キャプチャは不要
    // auto l5 = [=]{ return w.n_; };  // エラー: wはコピーによるキャプチャが必要
}

ラムダ本体がコピーによってキャプチャされたエンティティを ODR-use する場合、クロージャ型のメンバがアクセスされます。エンティティをODR-useしていない場合、アクセスは元のオブジェクトに対して行われます：

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // odr-useではない: gのconst int Nを参照
        f(&N); // odr-use: Nのキャプチャ（コピーによる）を引き起こす
               // &NはクロージャオブジェクトのメンバNのアドレスであり、gのNではない
    }();
}

ラムダが参照によってキャプチャされた参照をodr-useする場合、それはキャプチャされた参照自体ではなく、元の参照が指すオブジェクトを使用しています：

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // f内のxの使用は直接iにバインドされる
    i = 5;
    f(); // OK: 5を出力
}

キャプチャデフォルト = を持つラムダ本体内部では、キャプチャ可能なエンティティの型は、それがキャプチャされたかのようになります（したがって、ラムダが mutable でない場合、しばしばconst修飾が追加されます）。これは、エンティティが未評価オペランド内にあり、実際にはキャプチャされていない場合（例えば decltype 内）でも同様です：

void f3()
{
    float x, &r = x;
    [=]
    { // xとrはキャプチャされない（decltypeオペランド内での出現はodr-useではない）
        decltype(x) y1;        // y1はfloat型を持つ
        decltype((x)) y2 = y1; // y2はfloat const&型を持つ。なぜならこのラムダは
                               // mutableではなく、xは左辺値であるため
        decltype(r) r1 = y1;   // r1はfloat&型を持つ（変換は考慮されない）
        decltype((r)) r2 = y2; // r2はfloat const&型を持つ
    };
}

ラムダによって（暗黙的または明示的に）キャプチャされた任意のエンティティは、ラムダ式によってodr-usedされる（したがって、ネストされたラムダによる暗黙的キャプチャは、外側のラムダでの暗黙的キャプチャを引き起こす）。

暗黙的にキャプチャされるすべての変数は、ラムダの 到達可能スコープ 内で宣言されていなければなりません。

ラムダが外側のオブジェクトを（ this または * this として）キャプチャする場合、最も近い外側の関数は非静的メンバ関数であるか、ラムダは デフォルトメンバ初期化子 内になければなりません：

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 が外側のラムダ式によってキャプチャされていない
        }();
    }
};

ラムダ式が （またはジェネリックラムダの関数呼び出し演算子の特殊化） (C++14以降) * this または自動記憶域期間を持つ任意の変数をODR使用する場合、そのラムダ式によって捕捉されなければならない。

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N と M は odr-used されていない
                         // (キャプチャされていないことは問題ない)
            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 によって明示的にキャプチャされている
                };
            };
        }
    };
}

クラスメンバは初期化子なしのキャプチャで明示的にキャプチャできません（上述のように、 capture-list で許可されているのは variables のみです）:

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)を呼び出します
    }
};

ラムダがメンバーを暗黙的なコピーキャプチャでキャプチャする場合、そのメンバー変数のコピーは作成されません：メンバー変数 m の使用は式 ( * this ) . m として扱われ、 * this は常に暗黙的に参照によってキャプチャされます：

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // iのコピーとthisポインタのコピーをキャプチャ
                                      // 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の両方が
                                      // コピーによるキャプチャのように振る舞う
    }
};

ラムダ式が デフォルト引数 内に現れる場合、明示的または暗黙的に何もキャプチャすることはできません （すべてのキャプチャがデフォルト引数内に現れる式の制約を満たす初期化子を持つ場合を除く） (C++14以降) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // エラー: 何かをキャプチャしている
    void g2( int = [i] { return 0; }() ); // エラー: 何かをキャプチャしている
    void g3( int = [=] { return i; }() ); // エラー: 何かをキャプチャしている
    void g4( int = [=] { return 0; }() );       // OK: キャプチャなし
    void g5( int = [] { return sizeof i; }() ); // OK: キャプチャなし
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1はデフォルト引数内に
                                              //     現れることができる
    void g7( int = [x = i] { return x; }() ); // エラー: iはデフォルト引数内に
                                              //        現れることができない
}

匿名共用体 のメンバはキャプチャできません。 ビットフィールド はコピーによるキャプチャのみ可能です。

ネストされたラムダ m2 が、直近の外側のラムダ m1 によってもキャプチャされている何かをキャプチャする場合、 m2 のキャプチャは以下のように変換されます：

• 外側のラムダ m1 がコピーでキャプチャする場合、 m2 は元の変数や * this ではなく、 m1 のクロージャ型の非静的メンバをキャプチャする。 m1 がmutableでない場合、非静的データメンバはconst修飾されていると見なされる。
• 外側のラムダ m1 が参照でキャプチャする場合、 m2 は元の変数や * this をキャプチャする。

#include <iostream>
int main()
{
    int a = 1, b = 1, c = 1;
    auto m1 = [a, &b, &c]() mutable
    {
        auto m2 = [a, b, &c]() mutable
        {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2();
    };
    a = 2; b = 2; c = 2;
    m1();                             // m2()を呼び出し、123を出力
    std::cout << a << b << c << '\n'; // 234を出力
}

struct C 
{
    template<typename T>
    C(T);
};
void func(int i) 
{
    int x = [=](this auto&&) { return i; }();  // OK
    int y = [=](this C) { return i; }();       // error
    int z = [](this C) { return 42; }();       // OK
    auto lambda = [n = 42] (this auto self) { return n; };
    using Closure = decltype(lambda);
    struct D : private Closure {
        D(Closure l) : Closure(l) {}
        using Closure::operator();
        friend Closure;
    };
    D{lambda}(); // error
}

注記

暗黙的なラムダキャプチャのルールは、欠陥報告 P0588R1 によって若干変更されました。2023年10月現在、主要な実装の一部はこのDRを完全には実装しておらず、したがって odr-use を検出する旧ルールが一部の場合でまだ使用されています。

例

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> c{1, 2, 3, 4, 5, 6, 7};
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; }), c.end());
    std::cout << "c: ";
    std::for_each(c.begin(), c.end(), [](int i) { std::cout << i << ' '; });
    std::cout << '\n';
    // クロージャの型は名前を付けることができないが、autoで推論可能
    // C++14以降、ラムダはデフォルト引数を持つことが可能
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // すべての呼び出し可能オブジェクトと同様に、クロージャは std::function でキャプチャ可能
    // (これは不要なオーバーヘッドを招く可能性があります)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "再帰的ラムダ呼び出しをエミュレート:\nフィボナッチ数: ";
    auto nth_fibonacci = [](int n)
    {
        std::function<int(int, int, int)> fib = [&](int n, int a, int b)
        {
            return n ? fib(n - 1, a + b, a) : b;
        };
        return fib(n, 0, 1);
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci(i) << (i < fib_max ? ", " : "\n");
    std::cout << "ラムダ再帰の代替アプローチ:\nフィボナッチ数: ";
    auto nth_fibonacci2 = [](auto self, int n, int a = 0, int b = 1) -> int
    {
        return n ? self(self, n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci2(nth_fibonacci2, i) << (i < fib_max ? ", " : "\n");
#ifdef __cpp_explicit_this_parameter
    std::cout << "C++23のラムダ再帰へのアプローチ:\n";
    auto nth_fibonacci3 = [](this auto self, int n, int a = 0, int b = 1) -> int
    {
         return n ? self(n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci3(i) << (i < fib_max ? ", " : "\n");
#endif
}

c: 5 6 7
func1: 10
func2: 10
`再帰的ラムダ`呼び出しのエミュレート:
フィボナッチ数列: 0, 1, 1, 2, 3, 5, 8, 13
ラムダ再帰への代替アプローチ:
フィボナッチ数列: 0, 1, 1, 2, 3, 5, 8, 13

不具合報告

以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。

関連項目

外部リンク