在默认情况下，为什么C ++ 11的lambda要求“ mutable”关键字进行按值捕获？

简短示例：

#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。AFAIK，这应该是标准的）

它要求，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"
}

因此，您可以将lambda视为使用operator（）生成的类，除非您说它是可变的，否则该类默认为const。

您也可以将[]内部捕获的所有变量（显式或隐式）视为该类的成员：[=]对象的副本或[＆]对象的引用。当您声明lambda时就将它们初始化，就像有一个隐藏的构造函数一样。

我给人的印象是，按值捕获的全部目的是允许用户更改临时值-否则，使用按引用捕获几乎总是更好，不是吗？

问题是，它“几乎”吗？常见的用例似乎是返回或传递lambda：

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

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

我认为这mutable不是“几乎”的情况。我认为“按值捕获”类似于“允许我在捕获的实体死亡后使用其值”，而不是“允许我更改其副本”。但这也许可以争论。

FWIW，C ++标准化委员会的知名成员Herb Sutter，在Lambda正确性和可用性问题中为该问题提供了不同的答案：

考虑这个稻草人的例子，程序员在其中按值捕获局部变量，然后尝试修改捕获的值（它是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’

添加此功能的原因是担心用户可能不会意识到自己获得了副本，尤其是由于Lambda是可复制的，因此他可能会更改其他Lambda的副本。

他的论文是关于为什么要在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节：

lambda表达式的闭包类型具有公共内联函数调用运算符（13.5.4），其参数和返回类型分别由lambda表达式的parameter-declaration-clause和Trailingreturn-type描述。当且仅当lambdaexpression的parameter-declaration-clause不跟随可变变量时，此函数调用运算符才声明为const（9.3.1）。

编辑litb的评论：也许他们想到了按值捕获，以便变量的外部更改不会反映在lambda内部？参考是双向的，这就是我的解释。不知道这有什么好处。

编辑kizzx2的评论：使用lambda的大多数时间是作为算法的函子。默认的默认const性允许它在恒定的环境中使用，就像const可以在其中使用普通的合格函数一样，而在非const合格函数中则不能使用。也许他们只是想让这些案例更直观，因为他们知道自己的想法。:)

我给人的印象是，按值捕获的全部目的是允许用户更改临时值-否则，使用按引用捕获几乎总是更好，不是吗？

n是不是暂时的。n是您使用lambda表达式创建的lambda函数对象的成员。默认期望是调用lambda不会修改其状态，因此它是const，可以防止您意外修改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已更改为20lambda仍返回10（x仍在5lambda x内）在lambda内进行更改意味着在每次调用时都要更改lambda本身（在每次调用时lambda都会发生变异）。为了增强正确性，标准引入了mutable关键字。通过将lambda指定为可变的，您是说对lambda的每次调用都可能导致lambda本身发生变化。让我们看另一个例子：

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

}

上面的示例显示，通过使lambda可变，x在lambda内部进行更改会在每次调用时对lambda进行“突变”，x使其具有新的值与xmain函数中的实际值无关

现在有一个建议可以减轻对mutablelambda声明的需要：n3424

为了扩展Puppy的答案，lambda函数旨在为纯函数。这意味着给定唯一输入集的每个调用总是返回相同的输出。让我们定义输入为调用lambda时所有参数加上所有捕获的变量的集合。

在纯函数中，输出仅取决于输入，而不取决于某些内部状态。因此，任何lambda函数（如果是纯函数）都不需要更改其状态，因此是不可变的。

当lambda通过引用进行捕获时，在捕获的变量上进行写操作会影响纯函数的概念，因为纯函数应该做的就是返回输出，尽管lambda不一定会因为编写外部变量而发生变异。即使在这种情况下，正确的用法也意味着如果再次调用lambda时使用相同的输入，则尽管这些对by-ref变量产生了副作用，但每次的输出都将相同。此类副作用只是返回一些附加输入（例如，更新计数器）的方式，并且可以重新构造为纯函数，例如，返回元组而不是单个值。