C++11 和缺少多态 lambda - 为什么？

Question

我一直在审查C++11 标准的草稿版本。特别是 lambdas 部分，我对不引入多态 lambda 的原因感到困惑。

例如，在可以使用多态 lambda 的 100001 种方式中，我曾希望我们可以使用如下代码：

template<typename Container>
void foo(Container c)
{
    for_each(c.begin(), c.end(), [](T& t) { ++t; });
}

原因是什么：

• 是委员会没时间了吗？

• 多态 lambda 太难实现了？

• 或者也许PTB 不需要它们？

注意：请记住上面的例子不是唯一的，它只是作为代码类型的指南。仅专注于为上述代码段提供解决方法的答案将不被视为有效！

相关来源：

• Lambda expressions and closures for C++（文件编号 N1968=06-0038）
• Can lambda functions be templated?

Answer 1

this posting 很好地解释了我们没有多态 lambda 的原因。

这与从 C++11 中提取的概念特性有关：本质上，多态 lambda 是普通的、不受约束的函数模板，我们不知道如何对使用不受约束的模板的概念约束模板进行类型检查。但是，解决这个问题很容易，如here（死链接）所示，所以我认为没有任何障碍。

cpp-next 的链接已失效；相关信息可以找到here

Answer 2

由于参数 c 满足容器的 STL 要求，您应该可以使用类似的东西

template<typename Container>
void foo(Container c)
{
    for_each(c.begin(), c.end(),[](typename Container::reference t) { ++t; });
}

---

我还将在上面展示 John Purdy 的评论，这是在此 lambda 中获取所需类型名称的另一种方法：

template<typename Container>
void foo(Container c)
{
   for_each(c.begin(),c.end(),[](decltype(*c.begin()) t) { ++t; });
}

---

（是的，Dominar，我知道你不喜欢这个答案，因为它没有回答你的问题，但我敢打赌，下一个提出这个问题的人会寻找一种使他们的代码工作的方法，因此在与问题相关的地方使用一些技术确实很有意义。）

Answer 3

这可能是因为已经有一种语法可以做到这一点，而 lambdas 的目的是引入一种更简单的语法来涵盖大多数情况。当您尝试涵盖所有情况时（如果您希望自动生成的仿函数继承特定的基类怎么办？），您将失去 lambda 的相对优势（简单性和简洁性）。

我真的不喜欢建议的语法。 T 是关键字吗？名称查找失败的所有标识符是否都会自动转换为模板类型名参数？这可以防止您检测到拼写错误，而 IMO 是一个BAD 的想法：

for_each(c.begin(),c.end(),[](iterater& t) { ++t; });
// programmer misspelled "iterator" and now has a polymorphic lambda, oops

它还引入了远距离动作行为，如果在某个头文件中的某个地方引入了命名类型，则含义会突然改变。也真的很糟糕。

好吧，既然它应该创建一个模板，我们可以借用现有的语法：

for_each(c.begin(),c.end(),[]template<typename T>(T& t) { ++t; });

这是明确的，现在允许非类型模板参数（用于通过引用接受数组），但真的很笨拙。此时你最好手动写出函子，它会更容易理解。

但是，我认为使用 auto 关键字可以实现简单的语法：

for_each(c.begin(),c.end(),[](auto& t) { ++t; });

下一节错误地假设模板参数出现在仿函数类型上，而不是它的operator()()：

但是现在你有一个问题，for_each 推断一个类型名模板参数，而不是一个模板模板参数。在这种情况下，类型推断是不可能的。

在当前提案中，lambdas 具有类型，即使它是不可提及的（decltype 除外）类型。您必须失去该功能才能在调用站点进行推理。

显示问题不是 lambda 的缺点的示例，它只是一个不可演绎的上下文：

#include <vector>
#include <algorithm>
#include <iterator>

int main(void)
{
    using namespace std;
    vector<int> a(10);
    vector<int> b(10);
    vector<int> results;

    transform(a.begin(), a.end(), b.begin(), back_inserter(results), min<int>);
}

必须明确指定std::min 的模板类型参数。在这方面，Lambda 与使用现有函子没有什么不同。

编辑：好的，现在我意识到我们并不是建议 lambda 生成一个模板仿函数类型，而是一个实现模板函数应用运算符 (operator()()) 的单个非模板仿函数类型，我同意编译器应该能够生成这样的东西。我建议在这里使用auto 关键字将是一个很好的简单语法来请求它。

但是，我对auto 也不是很满意。带有多个参数的 lambdas 呢：

[](auto& x, auto& y){ return x + y; }
//becomes
template<typename T1, typename T2>
auto operator()(T1& x, T2& y) -> decltype(x + y) { return x + y; }

好的，这已经足够好了，但是如果我们想要两个参数但只有一个类型参数怎么办：

[](auto& x, decltype(x)& y){ return x + y; }
//becomes
template<typename T1>
auto operator()(T1& x, T1& y) -> decltype(x + y) { return x + y; }

看起来不错，但我发现语法具有误导性。语法表明类型参数是从第一个实参推断出来的，第二个参数被强制转换为相同的类型，但实际上在类型推断过程中两个实参被认为是相等的。

也许最好将这种情况限制为每个类型参数一个 lambda 参数，如果您想要更多限制，请自己编写仿函数。在我看来，这似乎是灵活性和功能与保持语法简单之间的良好折衷。

Answer 4

好吧，既然您已经链接了n1968，那么您的问题的答案就很明显了。可在提案的第 5.1 节中找到。

Answer 5

following（您对我上面其他答案的评论）有效：

#include <algorithm>
#include <vector>

struct foo
{
   template<typename T>
   void operator()(T& t)
   {
      ++t;
   }
};

int main()
{

   std::vector<int> v;
   std::for_each(v.begin (),v.end(),foo());

   return 0;
}

但以下不是：

#include <algorithm>
#include <vector>

template<typename T>
struct foo
{
   void operator()(T& t)
   {
      ++t;
   }
};

int main()
{

   std::vector<int> v;
   std::for_each(v.begin (),v.end(),foo()); // <-- the syntax for foo here 
                                            //     is kinda fictitious

   return 0;
}

C++ 委员会可能认为 lambdas 与第二个示例比第一个示例更相似。 （虽然我还没有想出聪明的方法来定义一个 lambda，这会有所作为。有人有什么疯狂的想法吗？）