在高阶函数中完美转发可调用对象

Question

I had been writing higher-order functions like this:

template<typename F, typename... Args>
void doStuff(F f, Args&&... args)
{
    // ...
    f(std::forward<Args>(args)...);
    // ...
}

Or maybe replace F f with F&& f .

But after I learned about ref-qualifiers (ouch), things got complicated. Imagine a functor class:

struct Foo {
    void operator()(...) &;
    void operator()(...) &&;
};

Then my previous implementations of doStuff will only ever call the & method, since parameters are always lvalues.

I think the way to resolve this is to implement doStuff like this:

template<typename F, typename... Args>
void doStuff(F&& f, Args&&... args)
{
    // ...
    std::forward<F>(f)(std::forward<Args>(args)...);
    // ...
}

This is also how std::result_of is possibly implemented . What I want to know is, is there any drawback to this implementation, ie, should I replace all my HOF implementations with it?

Answer 1

std::forward is a conditional r-value cast, and the point is as usual to steal the guts out of dying objects. There's no difference between functors and other objects in this respect. The down-side is same as with any use of std::forward ; if you are not prepared to steal those guts, you shouldn't.

#include <iostream>
#include <vector>

struct Foo {
    std::vector<int> vec = {1,2,3};
    std::vector<int>& operator()(...) & {
        return vec;
    }
    std::vector<int> operator()(...) && {
        return std::move(vec);
        // Clearly, don't rely on 'vec' here...
    }
};

Foo getFoo(){
    return {};
}

int main() {
    auto foo = getFoo();
    auto vec1=foo();
    auto vec2=getFoo()();
}

Clearly, don't do things like this:

auto vec3 = std::move(foo)();
vec4 = foo();

for the same reasons.