C ++存储功能可转发通用引用

Question

Is it possible to store a function that has similar behaviour to the following function:

void target(int foo, size_t bar) {}
void target(std::string foo, int bar) {} 

template<T...>
void forwarding_func(T&&... args)
{
    target(std::forward<T>(args)...);
}

auto forwarding_callable = ?

How would one build the callable object for types T that has the same behaviour as the forwarding_func. I have to store it for later use, so I do need a std::function object? Is it possible to even store lambdas like these in function objects?

auto f = [](auto&& x){
      myfunction(std::forward<decltype(x)>(x));
} 

Answer 1

You need a function object, that is, one with operator() . This operator should be a template and have the same (or similar) signature as forwarding_func . You can build one in a variety of ways.

The most straightforward way is to use C++17 generic lambda. If you can't use that, you can define your own:

struct forwarder {
    template <typename ... Args>
       void operator()(Args&& ... args) { ... etc }
};

There is a completely different way to create such forwarders. There is a proposal to add an overload function to the standard library. You would use it like this:

auto callable = std::overload (
   (void (*)(int, size_t))(target),
   (void (*)(std::string, int))(target)
);

Compilers don't implement std::overload as it isn't a part of any standard yet, but you can easily implement it yourself or find an implementation on the net (see this question for example).

Answer 2

Universal references and std::forward only make sense in function templates, as in this case you don't know whether your argument is an lvalue-reference or not. If it is, you want to pass it on as is, if not, you want to move it into the function you're forwarding to. That is exactly what std::foward does. Here 'sa very nice introduction to rvalue-references and perfect forwarding. As non-template functions specify whether they take their arguments by value or by (lvalue-)reference, you can just move or not move them accordingly and don't need std::foward .

As function templates are not actually functions themselves, you cannot store them in a lambda. You can however create a functor with a templated operator() :

struct Forwarding_Functor
{
    template<class... T>
    void operator()(T&&... args)
    {
        target(std::forward<T>(args)...);
    }
};