0

我的程序我有模板类，这些模板类主要是用于特殊用途的 std::function<..> 的包装器。最小的例子是：

template <typename... Args>
class Foo {

    public:

        explicit Foo(std::function<void(Args&&...)> _function)
            : function_(_function)
        {}

        template<typename... Arguments>
        void Bar(Arguments&&... _args) {
            function_(std::forward<Arguments>(_args)...);
        }

    private:

        std::function<void(Args&&...)> function_;

};

这些模板的实例化通常是左值引用、右值引用或无引用类型的组合。问题在于，当某些参数是非引用类型（例如 int 或 std::vector）时，调用 Bar 会导致错误。解决方法是声明一个临时变量，然后将其移动到函数调用中。 

int main(){
    Foo<int> test1([](int x) { });
    const int x = 1;
    test1.Bar(x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'

    int tmp = x;
    test1.Bar(tmp); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
    test1.Bar(std::move(tmp)); // [OK] But I don't want to have to reassign and move every time I use this.

    /* I want perfect forwarding on variables that can be forwarded. */
    /* There are cases when the templates are like this with a combination of l-value ref and r-value ref and non-ref types. */
    Foo<const std::vector<uint8_t>&, std::vector<uint8_t>&&, int> test2([](const std::vector<uint8_t>&, std::vector<uint8_t>&&, int) { });
    test2.Bar(std::vector<uint8_t>(1, 2), std::vector<uint8_t>(1, 2), x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'

    return 1;
}

我希望能够将 Bar 与任何模板参数一起使用，而不必每次都重新分配和 std::move() ，而且还可以完美地转发 ref 参数。有没有办法做到这一点？

编辑 在网上浏览了一下之后 - 问题std::function<void(Args&&...)> function_;不是一个采用通用 ref 而是采用 r-val ref 的函数。因此，尝试转发 no-ref 类型会引发错误。

那么问题是，是否有可能拥有并存储一个带有通用引用的 std::function ？

4

1 回答 1

2

在std::function<void(Args&&...)>中，您实际上期望 r 值参考，您可能想要std::function<void(Args...)>：

template <typename... Args>
class Foo {
public:
    explicit Foo(std::function<void(Args...)> _function)
        : function_(_function)
    {}

    template <typename... Arguments>
    void Bar(Arguments&&... _args) {
        function_(std::forward<Arguments>(_args)...);
    }

private:
    std::function<void(Args...)> function_;
};

演示

如果合适，您可以摆脱std::function：

template <typename F>
class Foo {
public:
    explicit Foo(F f) : f(f) {}

    template <typename... Ts>
    auto operator ()(Ts&&... args) const
    -> decltype(f(std::forward<Ts>(args)...))
    {
        return f(std::forward<Ts>(args)...);
    }

private:
    F f;
};

template <typename F>
Foo<F> MakeFoo(F f) { return Foo<F>{f}; }

演示

于 2019-02-28T09:43:16.190 回答