如何存储多态闭包？

Question

C++1y 提供多态 lambda（即，使用 auto 作为参数类型的一部分）：

int         f(int);
double      f(double);
std::string f(const std::string&);

auto funcObj = [](const auto& param){ return f(param); }

存储 lambda 生成的闭包很容易，如图所示：只需使用 auto 变量。但是假设我想创建一个vector 的此类对象。 vector 持有什么类型？通常的答案是使用std::function，但这在这种情况下不起作用，因为AFAIK没有多态std::function这样的东西，也就是说，这在C++ 1y中是不合法的：

std::vector<std::function<auto(const auto&)>> vecOfPolymorphicClosures;

如果这是合法的，那么你可以做一些事情，比如创建一个回调容器，每个回调容器都可以用任何一组参数调用，每个回调都可以返回一个依赖于传递参数类型的类型。至少在理论上，任何给定回调的结果都可以存储在auto 变量中。

两个问题：

• 在 C++1y 中是否可以声明一个变量或容器来保存不同类型的多态 lambda（boost::any 之类的除外）？
• 是否有理由希望这样的事情成为可能，或者这种事情与静态类型不兼容？

Answer 1

没有。也许吧。

对于您的特定情况，您的 lambda 只是实例化时已知的单个函数 f 的覆盖集。可以通过类型擦除创建和传递覆盖集对象，而不会出现太大问题。您只需要手动枚举覆盖并将其提供给覆盖集。

因此，如果您的目标只是拥有一个作为f 覆盖集的对象，是的，您可以这样做。见"Manual" signature overload resolution——在乱七八糟的上面加上一些类型的擦除，鲍勃就是你的叔叔。

一般情况下，您有一些 auto lambda，其中包含任意代码，没有。

设想这个问题的方法是想象一个用你的 lambda 编译的 DLL 或共享库，第二个 DLL 或共享库包含 function 类似对象，以及其他一些想要调用它的 DLL 或共享库。

当您调用 function 时发生的行为取决于 lambda 的定义和您要在任意程度上调用它的类型。

为了使其工作，几乎完整的运行时编译模型必须在创建 lambda 的 DLL 和调用它的类型的 DLL 中都可用，并且该运行时编译模型将必须兼容。

这既不是 C++ 标准所要求的，如果是这样的话，事情会变得更加复杂，并且会消除优化机会。

现在，并非一切都是绝望的。

如果有一些你想支持的固定类型列表，可以编写多态function 签名。这基本上是上面“覆盖集”解决方案的一个特例，甚至可以使用它来编写。

另一方面，如果您愿意键入擦除参数的属性到您的 lambda，并键入擦除，并返回一些统一类型（无论是 boost::any 或 boost::variant 或其他），您可以这样做某物。您编写一个类型擦除对象类型，并将其公开。然后你有一个std::function< boost::any(type_erasure_object) >，并且转换发生在调用之外，在你处理所述类型擦除对象的调用中。

使用类型擦除对象选择重载是很棘手的，因为 C++ 编译器无法帮助您生成要考虑的重载列表。如果您手动收集该列表，您甚至可以键入要选择的重载。

取消它是可能的，但我以前没有写过。这一切的替代方案都容易得多。

我不考虑使用类型擦除的情况来解决这个问题，因为它会阻止某些类型的优化。但从理论上讲，这意味着您可以使用几乎任意类型。

类型擦除对象必须向最终用户公开，并且它必须擦除 每一个您插入std::vector 需要的每个 lambda 类型信息知道。因此，在某些情况下，这会显着限制您在 std::vector 中存储的 lambda。

有关如何键入擦除几乎任意对象的示例，请查看 boost 类型擦除。

最后，您所要求的很少是问题的实际要求。您最好描述一下您的实际问题，几乎可以肯定它的解决方案不像上述那样深奥。

Answer 2

我要存储的是不同类型的对象，但每个对象都可以使用一组可能无限的参数类型来调用。

翻译单元A：

// a.cpp
#include <cassert>

std::vector<magical_type> v;

struct lives_in_a { int i; };

// defined in TU B:
void prepare();

int main()
{
    prepare();
    assert( v.front()(lives_in_a { 42 }) == 42 );
}

翻译单元B：

// b.cpp

struct lives_in_b {
    template<typename Anything>
    int operator()(Anything const& a) const
    { return a.i; }
};

void prepare()
{
    // ignore global initialization order fiasco for the sake
    // of the argument
    extern std::vector<magical_type> v;
    v.push_back(lives_in_b {});
}

lives_in_b::operator()<lives_in_a> 在何时何地被实例化，以便它可以被调用？

当v.front() 使用参数lives_in_a {} 调用时？在那种情况下，看不到lives_in_b 的定义，甚至无法实例化。

何时调用v.push_back(lives_in_b {})？在这种情况下，看不到 lives_in_a 的定义，所以没有什么可以做的实例化。

这证明了 C++ 编译模型和模板实例化工作方式的特定组合不允许这种特定的愿望。它与静态类型关系不大。

Answer 3

所谓的generic lambda的类型是一个类类型，其成员模板为operator()。当需要转换时，必须知道实际类型。对于非捕获的泛型 lambda，当前的草案标准甚至包含一个示例：

auto glambda = [](auto a) { return a; };
int (*fp)(int) = glambda;

这与从普通函数模板形成函数指针没有什么不同。

对于一般的通用 lambda，我想期望可调用对象的转换将触发正确的模板特化，因此 std::function<int(int)> f(glambda); 应该可以正常工作。