的这个例子非常清楚地表明，其意图是定义默认参数的地方也定义了语义：

int a = 1;
int f(int);
int g(int x = f(a));            // default argument: f(​::​a)

void h() {
  a = 2;
  {
    int a = 3;
    g();                        // g(f(​::​a))
  }
}

特别是，默认参数不仅仅是在函数调用时插入然后进行分析的标记序列。

按照这个意图，lambda 表达式是在默认参数定义时进行分析的，而不是在函数调用时。因此，lambda 类型只有一个，而不是多个，正确的结果是12。

但是，关于使用 lambda 表达式作为默认参数，标准并没有足够清楚地表达这一点。

这是来解释程序的行为，这意味着输出12是正确的。

来自：

如果 D 是模板，且在多个翻译单元中定义，则上述要求应适用于模板定义中使用的模板封闭范围的名称，也适用于实例化点 ([temp.dep]) 的依赖名称。这些要求也适用于 D 的每个定义中定义的相应实体（包括 lambda 表达式的闭包类型，但不包括 D 或未在 D 中定义的实体的默认参数或默认模板参数中定义的实体）。对于每个这样的实体和 D 本身，行为就像存在一个具有单个定义的单个实体，包括将这些要求应用于其他实体。

[注 4：实体仍在多个翻译单元中声明，并且 [basic.link] 仍适用于这些声明。特别是，出现在 D 类型中的 lambda 表达式 ([expr.prim.lambda]) 可能导致不同的声明具有不同的类型，并且出现在 D 的默认参数中的 lambda 表达式可能仍表示不同翻译单元中的不同类型。
— 结束注释]

[实施例6:

inline void f(bool cond, void (*p)()) {
 if (cond) f(false, []{});
}
inline void g(bool cond, void (*p)() = []{}) {
 if (cond) g(false);
}
struct X {
 void h(bool cond, void (*p)() = []{}) {
   if (cond) h(false);
 }
};

如果 的定义g出现在多个翻译单元中，则程序格式不正确（无需诊断），因为每个这样的定义都使用引用不同 lambda 表达式闭包类型的默认参数。
X 的定义可以出现在有效程序的多个翻译单元中； X 定义中 X​::​h 的默认参数内定义的 lambda 表达式在每个翻译单元中表示相同的闭包类型。 — 示例结束]

请注意，在您的示例中，函数定义foo仅出现在一个翻译单元中。给定的程序格式正确，并且您给出的示例中只有一个闭包类型（在单个 TU 中），因此12根据当前措辞，输出是正确的。

您说得对，每个 lambda 表达式都与一个唯一的闭包类型相关联，但是，决定类型的是表达式本身，而不是求值的次数。

因为我们正在讨论 lambda 表达式，所以我们处理的是 prvalue。对 prvalue 求值会初始化一个对象，该对象只有一个类型。

Lambda 表达式是一个 prvalue，其结果对象称为闭包对象。

Lambda 表达式的类型（也是闭包对象的类型）是一种唯一的、未命名的非联合类类型，称为闭包类型，其属性如下所述。

每次调用函数时，都会计算默认参数，而相应形参没有参数。

prvalue 是一个表达式，其求值初始化一个对象或计算一个运算符的操作数的值，如其出现的上下文所指定，或是一个具有 cv void 类型的表达式。

对象的属性在创建时就已确定。对象可以有一个名称。对象具有存储期限，这会影响其生命周期。对象具有类型。

表达式在整个执行过程中保持相同的类型

静态类型

不考虑执行语义而对程序进行分析得出的表达式类型

对于您的例子来说，12 是正确的结果。

这一切都归结为的解释：

Lambda 表达式的类型（也是闭包对象的类型）是一种唯一的、未命名的非联合类类型，称为闭包类型，其属性如下所述。

“独特”是什么意思？

“ Lambda 表达式的类型…是…独一无二的…”

第一个词是“the”。类型。暗示lambda 表达式只有一种类型。但由于它是“唯一的”，这意味着任何两个lambda 表达式都有不同的类型。

“ lambda 表达式”一词以斜体显示，表示语法术语。如果 lambda 在词汇中出现一次，但被求值多次，则每次求值时都是同一个lambda 表达式。因此，每次求值时，其类型都相同。

每次调用函数时都会评估默认参数，但这并不意味着程序的行为就像默认参数在每个调用点都一字不差地重复一样。默认参数是一段每次使用时都会运行的代码，就像函数体一样。

但请注意，实例化模板会复制模板定义中出现的每个语法生成（尽管出于名称查找目的，这与在实例化点“重放标记”不同）。换句话说，如果您在模板中有一个lambda 表达式，并且您实例化了该模板，则生成的特化将具有自己的lambda 表达式，这是实例化模板中 lambda 表达式的结果。因此，每个特化都会获得 lambda 的不同类型，即使这些 lambda 都是由同一原始源代码定义的。

还存在两个出现在不同翻译单元中的 lambda 实际上具有相同类型的情况。发生这种情况的原因是存在一条规则，该规则可以强制来自不同翻译单元的多个相同源代码片段表现得像程序中只有一个副本一样。

我没有对此进行正式证明，但我怀疑它会在单个翻译单元中按预期工作，但如果您使用多个翻译单元，那么您将有多个实例。基本上它将作为标头中定义的函数工作：

static inline int like_lambda()
{
    static int x = 0; return ++x;
}

这是。

这证明当使用多个翻译单元时

// side.h
#ifndef SIDE_H
#define SIDE_H

int foo(int x = [](){ static int x = 0; return ++x; }());
void side_test();

#endif

// side.cpp
#include "side.h"
#include <iostream>

int foo(int x) { return x; };

void side_test()
{
    std::cout << foo() << foo() << '\n'; 
}

// main.cpp
#include <iostream>
#include "side.h"

int main() {
    std::cout << foo() << foo() << '\n';
    side_test();
}

我认为最好的解决方法是回到函数重载并使代码更简单：

// side.h
#ifndef SIDE_H
#define SIDE_H

int foo(int x);
int foo();
void side_test();

#endif

// side.cpp
#include "side.h"
#include <iostream>

int foo()
{
   static int x = 0;
   return foo(++x);
}

int foo(int x) { return x; };

void side_test()
{
    std::cout << foo() << foo() << '\n'; 
}

foo定义函数时，会创建默认参数内的 lambda 表达式并建立其闭包。lambdastatic int x在其闭包内捕获。这意味着变量x与 lambda 本身相关联，而不是特定的函数调用。每次foo不带参数的调用都会评估 lambda，从而增加闭包内的静态变量。这就是为什么您会得到12输出，x在第一次调用时从 0 增加到 1，然后在第二次调用时从 1 增加到 2