C++
ラムダ

構文

• [ default-capture 、 capture-list ]（ 引数リスト ）変更可能なスロー指定 属性 - > return-type { lambda-body } //ラムダ指定子と属性の順序。
• [ キャプチャリスト ]（ 引数リスト ）{ lambda-body } //共通ラムダ定義。
• [=]（ 引数リスト ）{ lambda-body } //必要なすべてのローカル変数を値で取得します。
• [＆]（ 引数リスト ）{ lambda-body } //必要なすべてのローカル変数を参照によって取得します。
• [ capture-list ] { lambda-body } //引数リストと指定子を省略することができます。

パラメーター

備考

//Explicitly define this lambdas as constexpr
[]() constexpr {
    //Do stuff
}

ラムダ式とは何ですか？

ラムダ式は簡単な関数オブジェクトを作成する簡潔な方法を提供します。ラムダ式は、その結果オブジェクトが関数オブジェクトのように振る舞うクロージャオブジェクトと呼ばれる値である。

名前「ラムダ式」はラムダ計算から始まります。 ラムダ計算は、論理と計算能力についての質問を調べるために、1930年にアロンゾ教会によって発明された数学的形式論です。ラムダ計算は、関数型プログラミング言語LISPの基礎を形成しました。ラムダ計算とLISPと比較して、C ++のラムダ式は名前のないプロパティを共有し、周囲のコンテキストから変数を取得しますが、関数を操作して関数を返す機能がありません。

ラムダ式は、呼び出し可能なオブジェクトを取る関数の引数としてよく使われます。これは、引数として渡されたときにのみ使用される名前付き関数を作成するよりも簡単になります。そのような場合、関数式オブジェクトをインラインで定義できるので、ラムダ式が一般に好まれます。

ラムダは通常、キャプチャリスト[] 、オプションのパラメータリスト() 、およびボディ{}の3つの部分で構成され、これらはすべて空にすることができます。

[](){}                // An empty lambda, which does and returns nothing

キャプチャリスト

[]はキャプチャリストです。デフォルトでは、囲みスコープの変数にラムダでアクセスすることはできません。変数をキャプチャすると、ラムダ内でコピーまたは参照 としてアクセスできるようになります 。キャプチャされた変数はラムダの一部になります。関数の引数とは対照的に、ラムダを呼び出すときに渡す必要はありません。

int a = 0;                       // Define an integer variable
auto f = []()   { return a*9; }; // Error: 'a' cannot be accessed
auto f = [a]()  { return a*9; }; // OK, 'a' is "captured" by value
auto f = [&a]() { return a++; }; // OK, 'a' is "captured" by reference
                                 //      Note: It is the responsibility of the programmer
                                 //      to ensure that a is not destroyed before the
                                 //      lambda is called.
auto b = f();                    // Call the lambda function. a is taken from the capture list and not passed here.

パラメータリスト

()はパラメータリストで 、通常の関数とほぼ同じです。ラムダが引数を取らない場合は、これらのカッコを省略することができます（ラムダmutableを宣言する必要がある場合を除く）。これらの2つのラムダは同等です：

auto call_foo  = [x](){ x.foo(); };
auto call_foo2 = [x]{ x.foo(); };

auto sort_cpp11 = [](std::vector<T>::const_reference lhs, std::vector<T>::const_reference rhs) { return lhs < rhs; }; 
auto sort_cpp14 = [](const auto &lhs, const auto &rhs) { return lhs < rhs; }; 

機能体

{}は本体で 、通常の関数と同じです。

ラムダの呼び出し

ラムダ式の結果オブジェクトはクロージャであり、 operator()を使用して呼び出すことができます（他の関数オブジェクトと同様）。

int multiplier = 5;
auto timesFive = [multiplier](int a) { return a * multiplier; }; 
std::out << timesFive(2); // Prints 10

multiplier = 15;
std::out << timesFive(2); // Still prints 2*5 == 10

戻り値の型

デフォルトでは、ラムダ式の戻り値の型が導出されます。

[](){ return true; };

この場合、戻りbool型はboolです。

次の構文を使用して、戻り値の型を手動で指定することもできます。

[]() -> bool { return true; };

変更可能なラムダ

ラムダの値によって捕捉されたオブジェクトは、デフォルトでは不変です。これは、生成されたクロージャオブジェクトのoperator()がデフォルトでconstであるためです。

auto func = [c = 0](){++c; std::cout << c;};  // fails to compile because ++c
                                              // tries to mutate the state of
                                              // the lambda.

mutableというキーワードを使用すると、より近いオブジェクトのoperator() const変更することができます。

auto func = [c = 0]() mutable {++c; std::cout << c;};

戻り値の型とともに使用すると、その前にmutableが来ます。

auto func = [c = 0]() mutable -> int {++c; std::cout << c; return c;};

ラムダの有用性を示す例

C ++ 11以前：

// Generic functor used for comparison
struct islessthan
{
    islessthan(int threshold) : _threshold(threshold) {}

    bool operator()(int value) const
    {
        return value < _threshold;
    }
private:
    int _threshold;
};

// Declare a vector
const int arr[] = { 1, 2, 3, 4, 5 };
std::vector<int> vec(arr, arr+5);

// Find a number that's less than a given input (assume this would have been function input)
int threshold = 10;
std::vector<int>::iterator it = std::find_if(vec.begin(), vec.end(), islessthan(threshold));

C ++ 11以降：

// Declare a vector
std::vector<int> vec{ 1, 2, 3, 4, 5 };

// Find a number that's less than a given input (assume this would have been function input)
int threshold = 10;
auto it = std::find_if(vec.begin(), vec.end(), [threshold](int value) { return value < threshold; });

戻り値の型の指定

単一のreturn文を持つラムダ、または同じ型の式を持つ複数のreturn文の場合、コンパイラは戻り値の型を推定できます。

// Returns bool, because "value > 10" is a comparison which yields a Boolean result
auto l = [](int value) {
    return value > 10;
}

異なる型の複数のreturn文を持つlambdaの場合、コンパイラは戻り型を推論できません：

// error: return types must match if lambda has unspecified return type
auto l = [](int value) {
    if (value < 10) {
        return 1;
    } else {
        return 1.5;
    }
};

この場合、戻り値の型を明示的に指定する必要があります。

// The return type is specified explicitly as 'double'
auto l = [](int value) -> double {
    if (value < 10) {
        return 1;
    } else {
        return 1.5;
    }
};

このルールは、 autoタイプ控除のルールと一致します。明示的に指定された戻り値の型を持たないLambdaは参照を返すことはないので、参照型を望む場合は明示的に指定する必要があります：

auto copy = [](X& x) { return x; };       // 'copy' returns an X, so copies its input
auto ref  = [](X& x) -> X& { return x; }; // 'ref' returns an X&, no copy

値で取り込む

キャプチャリストに変数の名前を指定すると、ラムダは値でキャプチャします。これは、ラムダ用に生成されたクロージャタイプが変数のコピーを格納することを意味します。これはまた、変数の型をコピーコンストラクタブルにする必要があります。

int a = 0;

[a]() {
    return a;   // Ok, 'a' is captured by value
};

auto p = std::unique_ptr<T>(...);

[p]() {         // Compile error; `unique_ptr` is not copy-constructible
    return p->createWidget(); 
};

C ++ 14以降では、その場で変数を初期化することができます。これにより、移動のみのタイプをラムダに取り込むことができます。

auto p = std::make_unique<T>(...);

[p = std::move(p)]() {
    return p->createWidget(); 
};

ラムダは名前で変数を渡すときに変数を値で取り込みますが、デフォルトではその変数をラムダ本体内で変更することはできません。これは、closure型がラムダ本体をoperator() const宣言に入れるためです。

constは、クロージャ型のメンバ変数へのアクセスに適用され、クロージャのメンバであるキャプチャされた変数（逆のすべての外観）に適用されます。

int a = 0;

[a]() {
    a = 2;      // Illegal, 'a' is accessed via `const`

    decltype(a) a1 = 1; 
    a1 = 2; // valid: variable 'a1' is not const
};

constを削除するには、ラムダにキーワードmutableを指定する必要があります：

int a = 0;

[a]() mutable {
    a = 2;      // OK, 'a' can be modified
    return a;
};

aは値によって取得されたためaラムダを呼び出すことによって行われた変更はa影響aません。 aの値は構築時にラムダにコピーされたので、ラムダのaのコピーは外部a変数とは別です。

int a = 5 ; 
auto plus5Val = [a] (void) { return a + 5 ; } ; 
auto plus5Ref = [&a] (void) {return a + 5 ; } ; 

a = 7 ; 
std::cout << a << ", value " << plus5Val() << ", reference " << plus5Ref() ;
// The result will be "7, value 10, reference 12"

一般化されたキャプチャ

auto p = std::make_unique<T>(...);

auto lamb = [p = std::move(p)]() //Overrides capture-by-value of `p`.
{
  p->SomeFunc();
};

auto lamb_copy = lamb; //Illegal
auto lamb_move = std::move(lamb); //legal.

auto shared_lambda = [](auto&& f){
  return [spf = std::make_shared<std::decay_t<decltype(f)>>(decltype(f)(f))]
  (auto&&...args)->decltype(auto) {
    return (*spf)(decltype(args)(args)...);
  };
};
auto lamb_shared = shared_lambda(std::move(lamb_move));

int a = 0;

auto lamb = [&v = a](int add) //Note that `a` and `v` have different names
{
  v += add; //Modifies `a`
};

lamb(20); //`a` becomes 20.

auto lamb = [p = std::make_unique<T>(...)]()
{
    p->SomeFunc();
}

リファレンスによるキャプチャ

ローカル変数の名前の前に&つけると、変数は参照によって取り込まれます。概念的には、これは、ラムダのクロージャタイプが、ラムダのスコープの外側からの対応する変数への参照として初期化された参照変数を持つことを意味します。ラムダボディで変数を使用すると、元の変数が参照されます。

// Declare variable 'a'
int a = 0;

// Declare a lambda which captures 'a' by reference
auto set = [&a]() {
    a = 1;
};

set();
assert(a == 1);

mutableというキーワードは必要ではありません。なぜならa自身はconstはないからです。

もちろん、参照によって取得することは、ラムダがキャプチャする変数の範囲をエスケープしてはならないことを意味します。関数を呼び出す関数を呼び出すことはできますが、参照の範囲を超えてラムダを格納する関数を呼び出さないでください。そしてラムダを返さないでください。

デフォルトキャプチャ

デフォルトでは、キャプチャリストに明示的に指定されていないローカル変数には、ラムダ本体内からアクセスすることはできません。しかし、ラムダボディによって指定された変数を暗黙的に取り込むことは可能です：

int a = 1;
int b = 2;

// Default capture by value
[=]() { return a + b; }; // OK; a and b are captured by value

// Default capture by reference
[&]() { return a + b; }; // OK; a and b are captured by reference

明示的なキャプチャは暗黙的なデフォルトのキャプチャと並行して実行できます。明示的なキャプチャ定義は、デフォルトのキャプチャよりも優先されます。

int a = 0;
int b = 1;

[=, &b]() {
    a = 2; // Illegal; 'a' is capture by value, and lambda is not 'mutable'
    b = 2; // OK; 'b' is captured by reference
};

一般的なラムダ

auto twice = [](auto x){ return x+x; };

int i = twice(2); // i == 4
std::string s = twice("hello"); // s == "hellohello"

struct _unique_lambda_type
{
  template<typename T>
  auto operator() (T x) const {return x + x;}
};

[](auto x, int y) {return x + y;}

auto lamb1 = [](int &&x) {return x + 5;};
auto lamb2 = [](auto &&x) {return x + 5;};
int x = 10;
lamb1(x); // Illegal; must use `std::move(x)` for `int&&` parameters.
lamb2(x); // Legal; the type of `x` is deduced as `int&`.

auto lam = [](auto&&... args){return f(std::forward<decltype(args)>(args)...);};

auto lam = [](auto&&... args){return f(decltype(args)(args)...);};

boost::variant<int, double> value;
apply_visitor(value, [&](auto&& e){
  std::cout << e;
});

mutex_wrapped<std::ostream&> os = std::cout;
os.write([&](auto&& os){
  os << "hello world\n";
});

関数ポインタへの変換

ラムダのキャプチャリストが空の場合、ラムダは、同じ引数をとり、同じ戻り値の型を返す関数ポインタへの暗黙的な変換を行います。

auto sorter = [](int lhs, int rhs) -> bool {return lhs < rhs;};

using func_ptr = bool(*)(int, int);
func_ptr sorter_func = sorter; // implicit conversion

このような変換は、単項プラス演算子を使用して実行することもできます。

func_ptr sorter_func2 = +sorter; // enforce implicit conversion

この関数ポインタを呼び出すと、ラムダでoperator()を呼び出すのとまったく同じように動作します。この関数ポインタは、ソースラムダクロージャの存在に決して依存しません。したがって、ラムダ閉鎖よりも長く存続する可能性があります。

この機能は主に、C ++関数オブジェクトではなく関数ポインタを扱うAPIでlambdaを使用する場合に便利です。

auto sorter = [](auto lhs, auto rhs) { return lhs < rhs; };
using func_ptr = bool(*)(int, int);
func_ptr sorter_func = sorter;  // deduces int, int
// note however that the following is ambiguous
// func_ptr sorter_func2 = +sorter;

クラスラムダとこれのキャプチャ

クラスのメンバ関数で評価されるラムダ式は暗黙のうちにそのクラスの友人です：

class Foo
{
private:
    int i;
    
public:
    Foo(int val) : i(val) {}
    
    // definition of a member function
    void Test()
    {
        auto lamb = [](Foo &foo, int val)
        {
            // modification of a private member variable
            foo.i = val;
        };
        
        // lamb is allowed to access a private member, because it is a friend of Foo
        lamb(*this, 30);
    }
};

そのようなラムダは、そのクラスの友人であるだけでなく、クラス内で宣言されているクラスと同じアクセス権を持ちます。

Lambdasは、外部関数が呼び出されたオブジェクトインスタンスを表すthisポインタを取得できます。これは、 thisをキャプチャリストに追加することによって行われます。

class Foo
{
private:
    int i;
    
public:
    Foo(int val) : i(val) {}
    
    void Test()
    {
        // capture the this pointer by value
        auto lamb = [this](int val)
        {
            i = val;
        };
        
        lamb(30);
    }
};

thisが捕捉されると、ラムダはその包含クラスのメンバー名を、その包含クラスにあるかのように使用することができる。したがって暗黙のthis->がそのようなメンバーに適用されます。

thisは値によって取得されますが、型の値では取得されないことに注意してください。これはポインタであるthisの値によって取得されます 。そのため、ラムダが所有していないthis 。ラムダアウトがそれを作成したオブジェクトの生存期間にわたって存在する場合、ラムダは無効になる可能性があります。

これは、ラムダが変更mutableと宣言するthisなくthisを修正できることも意味します。それはオブジェクトではなく、 constであるポインタです。つまり、外部メンバ関数自体がconst関数でない限りです。

また、デフォルトのキャプチャ句（ [=]と[&]両方） も this暗黙的に取得することに注意してください。そして、両方ともポインタの値でキャプチャします。実際には、デフォルトが与えられたときにthisをキャプチャリストに指定するのは誤りです。

class Foo
{
private:
    int i;
    
public:
    Foo(int val) : i(val) {}
    
    void Test()
    {
        // capture a copy of the object given by the this pointer
        auto lamb = [*this](int val) mutable
        {
            i = val;
        };
        
        lamb(30); // does not change this->i
    }
};

ファンクタを使用してラムダ関数をC ++ 03に移植する

C ++のラムダ関数は、構文解析ツールを書くための非常に簡潔な構文を提供する構文的な砂糖です。したがって、ラムダ関数をファンクタに変換することによって、同等の機能をC ++ 03で得ることができます（はるかに冗長です）。

// Some dummy types:
struct T1 {int dummy;};
struct T2 {int dummy;};
struct R {int dummy;};

// Code using a lambda function (requires C++11)
R use_lambda(T1 val, T2 ref) {
  // Use auto because the type of the lambda is unknown.
  auto lambda = [val, &ref](int arg1, int arg2) -> R {
    /* lambda-body */
    return R();
  };
  return lambda(12, 27);
}

// The functor class (valid C++03)
// Similar to what the compiler generates for the lambda function.
class Functor {
  // Capture list.
  T1 val;
  T2& ref;

public:
  // Constructor
  inline Functor(T1 val, T2& ref) : val(val), ref(ref) {}

  // Functor body
  R operator()(int arg1, int arg2) const {
    /* lambda-body */
    return R();
  }
};

// Equivalent to use_lambda, but uses a functor (valid C++03).
R use_functor(T1 val, T2 ref) {
  Functor functor(val, ref);
  return functor(12, 27);
}

// Make this a self-contained example.
int main() {
  T1 t1;
  T2 t2;
  use_functor(t1,t2);
  use_lambda(t1,t2);
  return 0;
}

ラムダ関数がmutableあれば、ファンクタのcall-operatorを非const、すなわち：

R operator()(int arg1, int arg2) /*non-const*/ {
  /* lambda-body */
  return R();
}

再帰ラムダ

ユークリッドのgcd()をラムダとして書くとしましょう。関数として、次のようになります。

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a%b);
}

しかし、ラムダは再帰的に実行することはできません。ラムダを呼び出す方法はありません。ラムダには名前がありません。ラムダの本体内でthisを使用すると、 thisがキャプチャされたものを参照しthis （ラムダがメンバ関数の本体で作成されていると仮定します。そうでない場合はエラーです）。では、この問題をどうやって解決するのでしょうか？

std::function使用std::function

ラムダはまだ構築されていないstd::functionへの参照を取得することができstd::function ：

std::function<int(int, int)> gcd = [&](int a, int b){
    return b == 0 ? a : gcd(b, a%b);
};

これは機能しますが、控えめに使用する必要があります。それは遅いです（直接関数呼び出しの代わりにタイプ消去を使用しています）、壊れやすい（ gcdコピーするかgcdを返すことはラムダが元のオブジェクトを参照するので中断します）、汎用ラムダでは機能しません。

2つのスマートポインタの使用：

auto gcd_self = std::make_shared<std::unique_ptr< std::function<int(int, int)> >>();
*gcd_self = std::make_unique<std::function<int(int, int)>>(
  [gcd_self](int a, int b){
    return b == 0 ? a : (**gcd_self)(b, a%b);
  };
};

これは多くの間接参照（オーバーヘッド）を追加しますが、コピー/返すことができ、すべてのコピーは状態を共有します。それはあなたがラムダを返すことを可能にし、そうでなければ上記の解決策より脆弱ではありません。

Y-コンビネータを使用する

短いユーティリティ構造体の助けを借りて、これらの問題をすべて解決することができます：

template <class F>
struct y_combinator {
    F f; // the lambda will be stored here

    // a forwarding operator():
    template <class... Args>
    decltype(auto) operator()(Args&&... args) const {
        // we pass ourselves to f, then the arguments.
        // the lambda should take the first argument as `auto&& recurse` or similar.
        return f(*this, std::forward<Args>(args)...);
    }
};
// helper function that deduces the type of the lambda:
template <class F>
y_combinator<std::decay_t<F>> make_y_combinator(F&& f) {
    return {std::forward<F>(f)};
}
// (Be aware that in C++17 we can do better than a `make_` function)

私たちはgcdを次のように実装することができます：

auto gcd = make_y_combinator(
  [](auto&& gcd, int a, int b){
    return b == 0 ? a : gcd(b, a%b);
  }
);

y_combinatorは、ラムダ計算のコンセプトです。定義するまで、自分の名前を付けなくても再帰が可能です。これはまさにラムダの問題です。

あなたは最初の引数として "recurse"を取るラムダを作成します。あなたが再帰したいとき、あなたは再帰の引数を渡します。

y_combinatorは、その関数をその引数で呼び出すが、適切な "recurse"オブジェクト（つまり、 y_combinator自体）を最初の引数として持つ関数オブジェクトを返します。それはy_combinatorと呼ばれる残りの引数をラムダにも転送します。

要するに：

auto foo = make_y_combinator( [&](auto&& recurse, some arguments) {
  // write body that processes some arguments
  // when you want to recurse, call recurse(some other arguments)
});

重大な制限や重大なオーバーヘッドがなくラムダで再帰があります。

インラインパラメータパックのアンパックにlambdasを使用する

template<std::size_t...Is>
void print_indexes( std::index_sequence<Is...> ) {
  using discard=int[];
  (void)discard{0,((void)(
    std::cout << Is << '\n' // here Is is a compile-time constant.
  ),0)...};
}
template<std::size_t I>
void print_indexes_upto() {
  return print_indexes( std::make_index_sequence<I>{} );
}

template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index{};

template<class=void, std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&& f){
    using discard=int[];
    (void)discard{0,(void(
      f( index<Is> )
    ),0)...};
  };
}

template<std::size_t N>
auto index_over(index_t<N> = {}) {
  return index_over( std::make_index_sequence<N>{} );
}

template<class=void, std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&& f){
    ((void)(f(index<Is>)), ...);
  };
}

template<class Tup, class F>
void for_each_tuple_element(Tup&& tup, F&& f) {
  using T = std::remove_reference_t<Tup>;
  using std::tuple_size;
  auto from_zero_to_N = index_over< tuple_size<T>{} >();

  from_zero_to_N(
    [&](auto i){
      using std::get;
      f( get<i>( std::forward<Tup>(tup) ) );
    }
  );
}

template<std::size_t I>
void print_indexes_upto() {
  index_over(index<I>)([](auto i){
    std::cout << i << '\n'; // here i is a compile-time constant
  });
}

ライブで試してみましょう。