C++0x 的 lambda 表达式没有命名类型是不是很糟糕？

Question

我最近在互联网上阅读了一些有关 lambda 表达式的内容，在我看来，C++0x 的 lambda 表达式不会有一个（或多个）类型专门绑定到 lambda 表达式 - 换句话说，lambda表达式仅匹配模板参数或自动参数/变量。会发生什么，如所述这里，就是

支持 lambda 的编译器将 创建一个独特的匿名函子类型 对于每个 lambda 表达式

我的问题是，这是一件坏事吗？拥有一些仅与 lambda 表达式匹配的关键字（例如 lambda ）是否有意义，它的工作原理如下 说

void f(std::function<int(int)> func)
{
     func(2);
}

template<typename T>
void g(T func)
{
     func(2);
}

void h(lambda func)
{
     func(2);
}

int main()
{
    int fpointer(int);
    struct { int operator()(int var) { return var; } } functor;

    f(fpointer); //ok (actually a linker error, but for the sake of example)
    f(functor); //ok
    f([](int var) { return var; }); //ok

    g(fpointer); //ok
    g(functor); //ok
    g([](int var) { return var; }); //ok

    h(fpointer); //error -- function pointer isn't a lambda expr
    h(functor); //error -- functor isn't a lambda expr
    h([](int var) { return var; }); //ok

    return 0;
}

实话，我实际上看不出它的用处（特别是考虑到auto 接受 lambda 表达式，因此可以将 lambda 分配给变量），但 lambda 表达式是匿名类型并且不能专门绑定到一种特定类型，这仍然不适合我（排除所有其他人）。

从本质上讲，我的问题是，lambda 表达式是匿名的（无论是在实用性方面还是在功能上——缺少 lambda 类型是否会使我们失去某些功能——以及从哲学角度来看——是吗？ lambda 表达式始终具有“类型”auto）真的有意义吗？

Answer 1

Lambda 是独立类型。该代码

void h(lambda func)
{
     func(2);
}

没有任何意义，因为 lambda 不具有运行时多态性。回想一下，lambda 相当于

struct unique_name
{
    return_type operator()(Arg1 a1, Arg2 a2, ... , Argn an)
    {
        code_inside_lambda;
    }
}

它本身就是一个唯一的类型。上面的代码与“Which”相同，

void h(class C)
{
     C(2);
}

即使我们确保 C 有 operator() 也是没有意义的。您需要一个模板：

template<typename T>
void g(T func)
{
     func(2);
}

int main()
{
    g([](int x){return x + 2;});
}

Answer 2

我认为没有理由根据函数是否有名称来区分函数类型。 Lambda 函数只是一种简写，允许您轻松定义便利函数。无论有名称还是没有名称，调用函数时的行为都是相同的。

这样想吧。软件的早期版本有一个定义为匿名函数的谓词。随着时间的推移，需求变得更加复杂，你的谓词也变得更加复杂——也许你需要从多个地方调用它。明智的做法是重构，以便拥有一个命名函数。

被调用的函数（调用谓词的函数）没有理由关心这一点。简单或复杂，命名或匿名 - 它仍然只是一个谓词函数。

一个小问题是闭包 - 我还没有检查过，但运气好的话，C++ 将获得带有闭包和 lambda 的嵌套命名函数。