Question

C ++ 14引入了通用lambdas（在lambda签名中使用auto关键字时）。

有没有办法将它们存储在带有C ++ 17的矢量中？

我知道这个现有问题，但它不符合我的需求：Can I have a std::vector of template function pointers?

这是一个示例代码，说明了我想要做的事情。（请在回答之前查看底部的注释）

#include <functional>
#include <vector>

struct A {
    void doSomething() {
        printf("A::doSomething()\n");
    }
    void doSomethingElse() {
        printf("A::doSomethingElse()\n");
    }
};

struct B {
    void doSomething() {
        printf("B::doSomething()\n");
    }
    void doSomethingElse() {
        printf("B::doSomethingElse()\n");
    }
};

struct TestRunner {
    static void run(auto &actions) {
        A a;
        for (auto &action : actions) action(a);
        B b;
        for (auto &action : actions) action(b); // I would like to do it
        // C c; ...
    }
};

void testCase1() {
    std::vector<std::function<void(A&)>> actions; // Here should be something generic instead of A
    actions.emplace_back([](auto &x) {
        x.doSomething();
    });
    actions.emplace_back([](auto &x) {
        x.doSomethingElse();
    });
    // actions.emplace_back(...) ...
    TestRunner::run(actions);
}

void testCase2() {
    std::vector<std::function<void(A&)>> actions; // Here should be something generic instead of A
    actions.emplace_back([](auto &x) {
        x.doSomething();
        x.doSomethingElse();
    });
    actions.emplace_back([](auto &x) {
        x.doSomethingElse();
        x.doSomething();
    });
    // actions.emplace_back(...) ...
    TestRunner::run(actions);
}

// ... more test cases : possibly thousands of them
// => we cannot ennumerate them all (in order to use a variant type for the actions signatures for example)

int main() {
    testCase1();
    testCase2();

    return 0;
}

注意：

A，B和TestRunner的代码无法更改，只有测试用例的代码
我不想讨论这样的代码测试是好还是坏，这是偏离主题的（这里使用的测试术语只是为了说明我不能枚举所有lambdas（为了使用变量）为他们输入......））

Answer 1

它遵循一个可能的解决方案（我不推荐，但你明确表示你不想讨论它的好坏等等）。
根据要求，A，B和TestRunner尚未更改（暂时搁置auto不是TestRunner的有效函数参数这一事实因此）如果你可以略微改变TestRunner，整个事情都可以改进话虽这么说，这是代码：

#include <functional>
#include <vector>
#include <iostream>
#include <utility>
#include <memory>
#include <type_traits>

struct A {
    void doSomething() {
        std::cout << "A::doSomething()" << std::endl;
    }
    void doSomethingElse() {
        std::cout << "A::doSomethingElse()" << std::endl;
    }
};

struct B {
    void doSomething() {
        std::cout << "B::doSomething()" << std::endl;
    }
    void doSomethingElse() {
        std::cout << "B::doSomethingElse()" << std::endl;
    }
};

struct Base {
    virtual void operator()(A &) = 0;
    virtual void operator()(B &) = 0;
};

template<typename L>
struct Wrapper: Base, L {
    Wrapper(L &&l): L{std::forward<L>(l)} {}

    void operator()(A &a) { L::operator()(a); }
    void operator()(B &b) { L::operator()(b); }
};

struct TestRunner {
    static void run(std::vector<std::reference_wrapper<Base>> &actions) {
        A a;
        for (auto &action : actions) action(a);
        B b;
        for (auto &action : actions) action(b);
    }
};

void testCase1() {
    auto l1 = [](auto &x) { x.doSomething(); };
    auto l2 = [](auto &x) { x.doSomethingElse(); };

    auto w1 = Wrapper<decltype(l1)>{std::move(l1)};
    auto w2 = Wrapper<decltype(l2)>{std::move(l2)};

    std::vector<std::reference_wrapper<Base>> actions;
    actions.push_back(std::ref(static_cast<Base &>(w1)));
    actions.push_back(std::ref(static_cast<Base &>(w2)));

    TestRunner::run(actions);
}

void testCase2() {
    auto l1 = [](auto &x) {
        x.doSomething();
        x.doSomethingElse();
    };

    auto l2 = [](auto &x) {
        x.doSomethingElse();
        x.doSomething();
    };

    auto w1 = Wrapper<decltype(l1)>{std::move(l1)};
    auto w2 = Wrapper<decltype(l2)>{std::move(l2)};

    std::vector<std::reference_wrapper<Base>> actions;
    actions.push_back(std::ref(static_cast<Base &>(w1)));
    actions.push_back(std::ref(static_cast<Base &>(w2)));

    TestRunner::run(actions);
}

int main() {
    testCase1();
    testCase2();

    return 0;
}

我无法看到在矢量中存储非齐次lambda的方法，因为它们只是非均匀类型。
无论如何，通过定义一个接口（参见Base）并使用从给定接口和lambda继承的模板类（参见Wrapper），我们可以将请求转发给给定的通用lambda，并且仍然具有一个同质的界面换句话说，解决方案的关键部分是以下类：

struct Base {
    virtual void operator()(A &) = 0;
    virtual void operator()(B &) = 0;
};

template<typename L>
struct Wrapper: Base, L {
    Wrapper(L &&l): L{std::forward<L>(l)} {}

    void operator()(A &a) { L::operator()(a); }
    void operator()(B &b) { L::operator()(b); }
};

可以从lambda创建包装器，如下所示：

auto l1 = [](auto &) { /* ... */ };
auto w1 = Wrapper<decltype(l1)>{std::move(l1)};

不幸的是，由于要求不修改TestRunner，我必须使用std::ref和std::reference_wrapper才能将引用放入向量中。

在wandbox上查看。

Answer 2

基本上你想要的是std::function的扩展名。

std::function<Sig>是一种类型擦除的可调用对象，可以对该特定签名进行建模。我们需要所有这些功能，但需要更多签名，并且所有这些签名都是可重载的。这变得棘手的是我们需要线性堆栈的重载。这个答案假设新的C ++ 17规则允许在using声明中扩展参数包，并且将从头开始逐段构建。此答案并非专注于在必要时避免所有副本/电影，我只是建立脚手架。此外，还需要更多的SFINAE。

首先，我们需要一个给定签名的虚拟调用操作符：

template <class Sig>
struct virt_oper_base;

template <class R, class... Args>
struct virt_oper_base<R(Args...)>
{
    virtual R call(Args...) = 0;
};

将这些组合在一起的东西：

template <class... Sigs>
struct base_placeholder : virt_oper_base<Sigs>...
{
    virtual ~base_placeholder() = default;
    using virt_oper_base<Sigs>::call...;   // <3        
    virtual base_placeholder* clone() = 0; // for the copy constructor
};

现在讨厌的部分。我们需要placeholder<F, Sigs...>来覆盖每个call()。可能有更好的方法来实现这一点，但我能想到的最好的方法是拥有两个类型列表模板参数，并在我们完成它们时将每个签名从一个移动到另一个：

template <class... >
struct typelist;

template <class F, class Done, class Sigs>
struct placeholder_impl;

template <class F, class... Done, class R, class... Args, class... Sigs>
struct placeholder_impl<F, typelist<Done...>, typelist<R(Args...), Sigs...>>
    : placeholder_impl<F, typelist<Done..., R(Args...)>, typelist<Sigs...>>
{
    using placeholder_impl<F, typelist<Done..., R(Args...)>, typelist<Sigs...>>::placeholder_impl;

    R call(Args... args) override {
        return this->f(args...);
    }    
};

template <class F, class... Done>
struct placeholder_impl<F, typelist<Done...>, typelist<>>
    : base_placeholder<Done...>
{
    placeholder_impl(F f) : f(std::move(f)) { }
    F f;
};

template <class F, class... Sigs>
struct placeholder : 
    placeholder_impl<F, typelist<>, typelist<Sigs...>>
{
    using placeholder_impl<F, typelist<>, typelist<Sigs...>>::placeholder_impl;

    base_placeholder<Sigs...>* clone() override {
        return new placeholder<F, Sigs...>(*this);
    }
};

如果我绘制层次结构，这可能更有意义。我们说我们有两个签名：void(A&)和void(B&)：

virt_oper_base<void(A&)>       virt_oper_base<void(B&)>
   virtual void(A&) = 0;         virtual void(B&) = 0;
      ↑                          ↑
      ↑                          ↑
base_placeholder<void(A&), void(B&)>
   virtual ~base_placeholder() = default;
   virtual base_placeholder* clone() = 0;
      ↑
placeholder_impl<F, typelist<void(A&), void(B&)>, typelist<>>
   F f;
      ↑
placeholder_impl<F, typelist<void(A&)>, typelist<void(B&)>>
   void call(B&) override;
      ↑
placeholder_impl<F, typelist<>, typelist<void(A&), void(B&)>>
   void call(A&) override;
      ↑
placeholder<F, void(A&), void(B&)>
   base_placeholder<void(A&), void(B&)>* clone();

我们需要一种方法来检查给定的函数是否满足签名：

template <class F, class Sig>
struct is_sig_callable;

template <class F, class R, class... Args>
struct is_sig_callable<F, R(Args...)>
    : std::is_convertible<std::result_of_t<F(Args...)>, R>
{ };

现在，我们只使用所有这些。我们有一个顶级function类，它将拥有一个base_placeholder成员，其管理的生命周期。

template <class... Sigs>
class function
{   
    base_placeholder<Sigs...>* holder_;
public:
    template <class F,
        std::enable_if_t<(is_sig_callable<F&, Sigs>::value && ...), int> = 0>
    function(F&& f)
        : holder_(new placeholder<std::decay_t<F>, Sigs...>(std::forward<F>(f)))
    { }

    ~function()
    {
        delete holder_;
    }

    function(function const& rhs)
        : holder_(rhs.holder_->clone())
    { }

    function(function&& rhs) noexcept
        : holder_(rhs.holder_)
    {
        rhs.holder_ = nullptr;
    }

    function& operator=(function rhs) noexcept
    {
        std::swap(holder_, rhs.holder_);
        return *this;
    }

    template <class... Us>
    auto operator()(Us&&... us)
        -> decltype(holder_->call(std::forward<Us>(us)...))
    {
        return holder_->call(std::forward<Us>(us)...);
    }    
};

现在我们有一个带有值语义的多签名类型擦除函数对象。你想要的只是：

std::vector<function<void(A&), void(B&)>> actions;

Answer 3

无法以任何方式，形状或形式存储功能模板。它们不是数据。（函数也不是数据，但函数指针是）。请注意，有std :: function，但没有std :: function_template。有虚函数，但没有虚函数模板。有函数指针，但没有函数模板指针。这些都是一个简单事实的表现：运行时没有模板。

泛型lambda只是一个带有operator()成员函数模板的对象。以上所有内容也适用于成员模板。

您可以获得一组有限的，编译时确定的模板特化，使其像对象一样运行，但这与仅具有一组（可能是重载的）虚拟函数或函数指针的对象没有什么不同管他呢。在你的情况下，它相当于拥有

std::vector <
    std::tuple <
         std::function<void(A&)>,
         std::function<void(B&)>
    >
 >

应该可以将通用lambda转换为具有自定义转换函数的这样一对，或者甚至可以在具有operator（）成员模板的对象中进行包装，因此从外部看起来它看起来确实是什么你想要---但它只适用于A和B类型而不是其他任何东西。要添加其他类型，您必须向元组添加另一个元素。

C ++ 17向量的通用（多态）lambdas

3 个答案: