使用std :: function或转发引用作为高阶函数的通用可调用对象输入参数？

Question

I was wondering about the main differences, pros and cons in writing a higher order function taking, as input parameter, a std::function or a forwarding reference , eg template<typename F> void hof(F&& fun); . Obviously, the former is more strict than the latter in that it specifies the function type that the input callable object has to conform to.

Answer 1

std::function often has a significant run-time overhead. Passing a generic callable object through a template parameter avoids std::function 's indirection costs and allows the compiler to aggressively optimize .

I wrote some simple benchmarks for lambda recursion (Y-combinator vs std::function ) at the end of this article . std::function always generates at least 3.5x times more assembly than a non-polymorphic Y-combinator implementation. This is a decent example that shows how std::function can be more expensive than a template parameter.

I suggest playing around on gcc.godbolt.org to see assembly differences between the two techniques.

---

Here's an example I just came up with :

#if defined(STDFN)
void pass_by_stdfn(std::function<void()> f)
{
    f();
}
#else
template <typename TF>
void pass_by_template(TF&& f)
{
    f();
}
#endif

volatile int state = 0;

int main()
{
#if defined(STDFN)
   pass_by_stdfn([i = 10]{ state = i; });
#else
   pass_by_template([i = 10]{ state = i; });  
#endif
}

With STDFN not defined , the generated assembly is:

main:
        mov     DWORD PTR state[rip], 10
        xor     eax, eax
        ret
state:
        .zero   4

With STDFN defined , the generated assembly is 48 lines long.

Answer 2

std::function has a lot of pros, but it has also a series of cons that you must take into account.
As an example:

• The callable object should be copy constructible.
  In other terms, this compiles:

   #include <functional> #include <utility> #include <memory> template<typename F> void func(F &&f) { std::forward<F>(f)(); } int main() { func([ptr = std::make_unique<int>()](){}); } 

  But this does not:

   #include <functional> #include <utility> #include <memory> void func(std::function<void(void)> f) { f(); } int main() { func([ptr = std::make_unique<int>()](){}); } 

• Even though (emphasis mine):

  Implementations are encouraged to avoid the use of dynamically allocated memory for small callable objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer.

  You have no guarantees that you won't have allocations on the dynamic storage when they could be avoided, and you'll have allocations for sure in all the other cases.

• When you construct a std::function , the constructor may throw a bad_alloc .

• ... Probably we can continue, but it doesn't worth it, you got the point.

std::function s are in incredible useful tool, but you should use them when you need them.
As an example, if you plan to store your function somewhere, likely you will end up using a std::function . On the other side, if you plan to accept a callable object and invoke it on the fly, probably you won't use a std::function .
These are only a few examples, a golden rule doesn't exist unfortunately.