C ++ 11のラムダで、値によるキャプチャにデフォルトで「可変」キーワードが必要なのはなぜですか？

短い例：

#include <iostream>

int main()
{
    int n;
    [&](){n = 10;}();             // OK
    [=]() mutable {n = 20;}();    // OK
    // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
    std::cout << n << "\n";       // "10"
}

質問：なぜmutableキーワードが必要なのですか？名前付き関数に渡す従来のパラメーターとはかなり異なります。背後にある理論的根拠は何ですか？

値によるキャプチャの全体のポイントは、ユーザーが一時変数を変更できるようにすることだという印象を受けました。それ以外の場合は、ほとんどの場合、参照によるキャプチャを使用した方がよいのではないでしょうか。

悟りはありますか？

（ちなみに私はMSVC2010を使用しています。これは標準のはずです）

mutableデフォルトでは、関数オブジェクトは呼び出されるたびに同じ結果を生成する必要があるためです。これは、オブジェクト指向関数とグローバル変数を効果的に使用する関数の違いです。

あなたのコードはこれとほぼ同等です：

#include <iostream>

class unnamed1
{
    int& n;
public:
    unnamed1(int& N) : n(N) {}

    /* OK. Your this is const but you don't modify the "n" reference,
    but the value pointed by it. You wouldn't be able to modify a reference
    anyway even if your operator() was mutable. When you assign a reference
    it will always point to the same var.
    */
    void operator()() const {n = 10;}
};

class unnamed2
{
    int n;
public:
    unnamed2(int N) : n(N) {}

    /* OK. Your this pointer is not const (since your operator() is "mutable" instead of const).
    So you can modify the "n" member. */
    void operator()() {n = 20;}
};

class unnamed3
{
    int n;
public:
    unnamed3(int N) : n(N) {}

    /* BAD. Your this is const so you can't modify the "n" member. */
    void operator()() const {n = 10;}
};

int main()
{
    int n;
    unnamed1 u1(n); u1();    // OK
    unnamed2 u2(n); u2();    // OK
    //unnamed3 u3(n); u3();  // Error
    std::cout << n << "\n";  // "10"
}

したがって、ラムダは、可変であると言わない限り、デフォルトでconstになるoperator（）でクラスを生成すると考えることができます。

[]内で（明示的または暗黙的に）キャプチャされたすべての変数を、そのクラスのメンバーとして考えることもできます。[=]のオブジェクトのコピーまたは[＆]のオブジェクトへの参照。隠しコンストラクタがあるかのようにラムダを宣言すると、これらは初期化されます。

値によるキャプチャの全体のポイントは、ユーザーが一時変数を変更できるようにすることだという印象を受けました。それ以外の場合は、ほとんどの場合、参照によるキャプチャを使用した方がよいのではないでしょうか。

問題は、「ほとんど」ですか。よく使用されるのは、ラムダを返すか渡すことです。

void registerCallback(std::function<void()> f) { /* ... */ }

void doSomething() {
  std::string name = receiveName();
  registerCallback([name]{ /* do something with name */ });
}

それmutableは「ほとんど」の場合ではないと思います。「値のキャプチャ」は、「値のコピーを変更できるようにする」ではなく、「値がキャプチャされたエンティティが終了した後でその値を使用できるようにする」などと考えています。しかし、おそらくこれは議論の余地があります。

C ++標準化委員会の有名なメンバーであるFWIW、Herb Sutterは、Lambdaの正確性と使いやすさの問題で、その質問に対する別の回答を提供しています。

プログラマーがローカル変数を値でキャプチャーし、キャプチャーした値（ラムダオブジェクトのメンバー変数）を変更しようとする、このストローマンの例を考えてみましょう。

int val = 0;
auto x = [=](item e)            // look ma, [=] means explicit copy
            { use(e,++val); };  // error: count is const, need ‘mutable’
auto y = [val](item e)          // darnit, I really can’t get more explicit
            { use(e,++val); };  // same error: count is const, need ‘mutable’

この機能は、ユーザーがコピーを取得したことに気付かない可能性があること、特にラムダはコピー可能であるため、別のラムダのコピーを変更する可能性があるという懸念から追加されたようです。

彼の論文は、これがC ++ 14で変更されるべき理由についてです。この特定の機能に関して「[委員会メンバー]の考え方」を知りたい場合は、短く、よく書かれており、読む価値があります。

Lambda関数のクロージャタイプは何かを考える必要があります。Lambda式を宣言するたびに、コンパイラーはクロージャー型を作成します。これは、属性（Lambda式が宣言されている環境）と関数呼び出しが::operator()実装された名前のないクラス宣言にほかなりません。copy-by-valueを使用して変数をキャプチャすると、コンパイラはconstクロージャタイプに新しい属性を作成します。これは、「読み取り専用」属性であるため、Lambda式内で変更できないためです。これを「クロージャ」と呼びます。何らかの方法で、変数を上位スコープからLambdaスコープにコピーしてLambda式を閉じるため、」ます。mutable、キャプチャされたエンティティはなりnon-const閉鎖タイプの属性。これにより、値によってキャプチャされた可変変数で行われた変更が上位スコープに伝播されず、ステートフルなLambda内に保持されます。Lambda式の結果として生じるクロージャタイプを常に想像してみてください。それが私を大きく助けました。それがあなたにも役立つことを願っています。

5.1.2 [expr.prim.lambda]の5節の次のドラフトを参照してください。

ラムダ式のクロージャ型には、パブリックインライン関数呼び出し演算子（13.5.4）があり、そのパラメータと戻り値の型は、ラムダ式のparameter-declaration-clauseとtrailingreturn-typeによってそれぞれ記述されます。この関数呼び出し演算子は、ラムダ式のparameter-declaration-clauseの後にミュータブルが続かない場合にのみconst（9.3.1）と宣言されます。

litbのコメントを編集：変数への外部の変更がラムダの内部に反映されないように、値によるキャプチャを考えたのでしょうか？参照は両方の方法で機能するので、それが私の説明です。それが良いかどうか分からない。

kizzx2のコメントを編集：ラムダが使用されるほとんどの場合は、アルゴリズムのファンクタとして使用されます。デフォルトの状態constでは、通常のconst修飾された関数はそこで使用できますが、const修飾されていない関数は使用できないように、定数環境で使用できます。多分彼らは彼らの心の中で何が起こっているかを知っているそれらの場合のためにそれをより直感的にすることを考えただけかもしれません。:)

値によるキャプチャの全体のポイントは、ユーザーが一時変数を変更できるようにすることだという印象を受けました。それ以外の場合は、ほとんどの場合、参照によるキャプチャを使用した方がよいのではないでしょうか。

n一時的なものではありません。nは、ラムダ式を使用して作成するラムダ関数オブジェクトのメンバーです。デフォルトの想定では、ラムダを呼び出してもその状態は変更されないため、誤ってを変更しないようにする必要がありますn。

キャプチャの意味を理解する必要があります！引数の受け渡しではなくキャプチャしています！いくつかのコードサンプルを見てみましょう。

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() {return x + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //output 10,20

}

ご覧のとおり、ラムダにx変更されても、2010が返されます（xまだ5ラムダx内にあります）。ラムダ内を変更すると、各呼び出しでラムダ自体が変更されます（ラムダは各呼び出しで変化します）。正確さを強制するために、標準はmutableキーワードを導入しました。ラムダを可変として指定することにより、ラムダへの各呼び出しがラムダ自体に変更を引き起こす可能性があることを意味します。別の例を見てみましょう：

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() mutable {return x++ + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //outputs 11,20

}

上記の例は、ラムダを可変にしxて、ラムダ内を変更するたびに、呼び出しごとに新しい値でラムダを「変更」し、メイン関数のx実際の値とは関係がないことを示していxます。

現在、mutableラムダ宣言の必要性を緩和する提案があります：n3424

パピーの答えを拡張するために、ラムダ関数は純粋な関数であることが意図されています。つまり、一意の入力セットが指定されたすべての呼び出しは、常に同じ出力を返します。ラムダが呼び出されたときに、すべての引数とキャプチャされたすべての変数のセットとして入力を定義しましょう。

純粋な関数では、出力は一部の内部状態ではなく入力のみに依存します。したがって、ラムダ関数は、純粋であれば、その状態を変更する必要がないため、不変です。

ラムダが参照によってキャプチャする場合、キャプチャされた変数への書き込みは、純粋な関数の概念に対する負担になります。これは、純粋な関数が行うべきことはすべて出力を返すことです。この場合でも正しい使用法は、参照による変数へのこれらの副作用にもかかわらず、ラムダが同じ入力で再度呼び出された場合、出力は毎回同じになることを意味します。このような副作用は、追加の入力（カウンターの更新など）を返すための単なる方法であり、単一の値の代わりにタプルを返すなど、純粋な関数に再構成できます。