关于函数模板中定义的 lambda 闭包类型可以说什么？

Question

我知道 lambda 的类型是“隐藏的”并且是唯一的。但是“唯一”的确切含义是什么，相同的 lambda 代码是否给出相同的类型？

（如果可能）我想使用这个“不变量”进行类型检查，如下所示：

#include <type_traits>

template <typename T>
auto foo(const T y)
{
  return [=](T x) { return x * y; }; 
}

int main()
{
  auto f1 = foo<int>(4.);
  auto f2 = foo<int>(6.); // fails with auto f2 = foo<double>(6.);

  static_assert(std::is_same_v<decltype(f1), 
                               decltype(f2)>); // is this ok or undefined behavior?
}

在此之前，我想确定 c++ 标准是怎么说的：它是正常的还是未定义的行为？

（这段代码被g++和clang++编译成功，但只是标准真题）

---

作为补充更符合最初的标题（抱歉，这有点晚了，因为我不得不离开我的办公室），这是一个更强大的版本，不编译：

#include <type_traits>

template <typename T>
auto foo_1(const T y)
{
  return [=](T x) { return x * y; };
}

template <typename T>
auto foo_2(const T y)
{
  return [=](T x) { return x * y; };
}

int main()
{
  auto f1 = foo_1<int>(4.);
  auto f2 = foo_2<int>(6.);

  static_assert(std::is_same_v<decltype(f1), decltype(f2)>); // fails!
}

Answer 1

确实，标准并没有明确说明“独特”的含义，但我认为我们可以弄清楚。

首先，请注意标准中的“唯一、未命名的非联合类类型”。形容词“未命名”足以暗示 lambda 闭包类型永远不会与使用 struct 或 class 关键字或标准库定义的某些命名类相同（例如，lambda 闭包类型不能是 @ 987654324@).

那么，为什么标准会说“独特的、未命名的”？它一定告诉我们一些关于两种不同 lambda 闭包类型之间的比较。不过，在许多情况下，这将是多余的。如果我们有两个 lambda 表达式，例如：

auto f1 = [](int x) { return x; };
auto f2 = [](int x) { return 2*x; };

很明显，两个 lambda 表达式不能具有相同的类型，因为它们的函数调用运算符具有不同的行为。因此，每个闭包类型是“唯一”的声明不会告诉我们任何关于f1 和f2 的未知信息。

但是，如果我们现在看：

auto f3 = [](int x) { return x; };
auto f4 = [](int x) { return x; };

在这里，“唯一”可以解释为 f3 和 f4 肯定有不同的类型，即使 lambda 表达式具有相同的拼写和相同的行为。

在这种情况下，这通常被认为是“独特”的含义。如果标准不是说f3 和f4 有不同的类型，那么根本没有理由使用“唯一”这个词。相反，它只会说“未命名”，而不是“唯一的、未命名的”。

接下来的问题是，唯一性延伸到什么程度。这可能意味着 lambda 表达式的每次评估都会产生不同的类型吗？不，不可能是这个意思。这将使表达式的静态类型取决于它已执行的次数（运行时属性），这是荒谬的。考虑一下如果每次执行 foo<int> 时您的 foo<int> 的 lambda 具有不同的类型会发生什么。这意味着foo<int> 的签名在每次调用时都会改变。这不可能。 foo<int> 中的 lambda 必须始终具有相同的类型。

至于您的foo_1 和foo_2 的情况，这两种lambda 类型肯定是不同的。同样，如果不是这样，“独特”一词将是多余的。

Answer 2

您所做的断言不是未定义的行为。闭包类型是 impl 定义的。一旦你在同一个编译器中比较了 lambda 表达式类型，就没有问题了。