Lambda捕获类型推导规则为何与auto存在差异？

Great question! This is a super common gotcha when working with lambdas, and it all boils down to the different design goals behind lambda capture rules and auto type deduction. Let’s unpack this step by step.

First, let’s confirm your observation is spot-on. When you capture a const object by value in a lambda:

const int x = 0;
auto foo = [x]{ 
    // x here is definitely const int — try assigning to it, and the compiler will throw an error!
};

As you noted, the C++17 standard (§8.1.5.2) explicitly spells this out:

对于每个按副本捕获的实体，闭包类型中会声明一个未命名非静态数据成员，其声明顺序未指定。若实体为对象引用，该数据成员类型为被引用类型；若为函数引用，则为被引用函数类型的左值引用；其余情况则为对应捕获实体的类型。匿名联合的成员不得按副本捕获。

Why Lambdas Keep the Const Qualifier #

The core idea here is that lambda captures are designed to faithfully mirror the original entity’s type when capturing by value (with exceptions for references, as called out in the standard). This isn’t an oversight — it’s intentional:

• It preserves the semantic contract of the original variable. If x was declared const, the lambda shouldn’t get a free pass to modify its copy unless you explicitly opt into that.
• Closure members are meant to be exact copies of what you captured. If the original was const, the copy stays const to prevent accidental modifications that go against the original variable’s intended use.

How Auto Type Deduction Is Different #

On the flip side, auto is built for convenience when creating new variables. By default, it strips top-level const (and volatile) qualifiers when deducing from an object (not a reference). For example:

const int x = 0;
auto y = x; // y is just int, not const int — you can modify it freely

This makes sense because most of the time, when you copy a const object into a new variable, you want that copy to be modifiable unless you explicitly say otherwise (like const auto y = x;).

The Root of the Difference #

At the end of the day, it’s all about what each feature is designed to do:

• Lambda captures: Prioritize semantic consistency with the context they’re defined in. The captured copy should behave just like the original variable did, including its constness.
• Auto deduction: Prioritizes flexibility for creating new, usable variables. It assumes you want a modifiable copy by default.

If you do want to modify the captured variable inside the lambda, you can use the mutable keyword — this removes the const-qualification from the closure’s data members:

const int x = 0;
auto foo = [x]() mutable { 
    x = 1; // Now this compiles perfectly!
};

内容的提问来源于stack exchange，提问作者Mr. Anderson