Best way of passing callback function parameters in C++

Question

What is the best way of passing a callback function parameter in C++?

I thought of simply using templates, like this:

template <typename Function>
void DoSomething(Function callback)

This is the way used e.g. in std::sort for the comparison function object.

What about passing using &&? E.g.:

template <typename Function>
void DoSomething(Function&& callback)

What are the pros and cons of those two methods, and why does the STL uses the former e.g. in std::sort?

Answer 1

The

template <typename Function>
void DoSomething(Function&& callback)

… which uses a forwarding reference to pass by reference, is IMHO superior for the case where the function just uses the callback. Because a functor object, although usually small, can be arbitrarily large. Passing it by value then incurs some needless overhead.

The formal argument can end up as T&, T const& or T&& depending on the actual argument.

---

On the other hand, passing a simple function pointer by reference involves an extra needless indirection, which in principle could mean some slight overhead.

If in doubt whether this is significant for a given compiler, system and application, then measure.

---

Regarding

” why does the STL uses the former [passing by value] e.g. in std::sort?

… it's worth noting that std::sort has been there since C++98, well before forwarding references were introduced in C++11, so it could not have that signature originally.

Possibly there just has not been sufficient incentive to improve this. After all, one should generally not fix that which works. Still, extra overloads with an “execution policy” argument are introduced in C++17.

Since this concerns a possible C++11 change, it's not covered by the usual source for rationales, namely Bjarne Stroustrup's “The design and evolution of C++”., and I do not know of any conclusive answer.

---

Using the template<class F> void call( F ) style, you can still get back "pass by reference". Simply do call( std::ref( your callback ) ). std::ref overrides operator() and forwards it to the contained object.

Similarly, with template<class F> void call( F&& ) style, you can write:

template<class T>
std::decay_t<T> copy( T&& t ) { return std::forward<T>(t); }

which explicitly copies something, and force call to use a local copy of f by:

call( copy(f) );

so the two styles mainly differ in how they behave by default.

---

Answer 2

Since this is C++11 (or higher): <functional> and std::function are your best friends here.

#include <iostream>
#include <functional>
#include <string>


void DoSomething(std::function<void()> callback) {
    callback();
}

void PrintSomething() {
   std::cout << "Hello!" << std::endl;
}

int main()
{
    DoSomething(PrintSomething);
    DoSomething([]() { std::cout << "Hello again!" << std::endl; });
}

Answer 3

In my opinion, using the && would be the superior way, basically because it avoids copy constructing the functor when the argument is an lvalue. In case of a lambda, this means avoiding to copy construct all captured values. In case of an std::function you also have an additional heap allocation unless small object optimizations are used.

But there are some cases when it could be a good thing to have a copy of the functor. One example is when using a generator function object like this:

#include <functional>
#include <cstdio>

template <typename F>
void func(F f) {
        for (int i = 0; i < 5; i++) {
                printf("Got %d\n", (int)f());
        }
}

int main() {
        auto generator0 = [v = 0] () mutable { return v++; };
        auto generator1 = generator0; generator1();

        printf("Printing 0 to 4:\n");
        func(generator0);
        printf("Printing 0 to 4 again:\n");
        func(generator0);
        printf("Printing 1 to 5:\n");
        func(generator1);
}

If we used F&& instead, the second group of prints would print values 5 to 9 instead of 0 to 4. I guess it's up to the application/library what behaviour is preferred.

When using function pointers, we could also end up in a situation when an extra level of indirection must be used in the invoke2 function:

template <typename F>
void invoke1(F f) {
        f();
}

template <typename F>
void invoke2(F&& f) {
        f();
}

void fun();

void run() {
        void (*ptr)() = fun;
        void (&ref)() = fun;

        invoke1(fun); // calls invoke1<void (*)()>(void (*)())
        invoke1(&fun);// calls invoke1<void (*)()>(void (*)())
        invoke1(ptr); // calls invoke1<void (*)()>(void (*)())
        invoke1(ref); // calls invoke1<void (*)()>(void (*)())

        invoke2(fun); // calls invoke2<void (&)()>(void (&)())
        invoke2(&fun);// calls invoke2<void (*)()>(void (*&&)())
        invoke2(ptr); // calls invoke2<void (*&)()>(void (*&)())
        invoke2(ref); // calls invoke2<void (&)()>(void (&)())
}

The statement invoke2(&fun); puts the address to the function on the stack, then sends the reference (i.e. an address) to this temporary stack slot to the invoke2 function. The invoke2 function must then use an extra memory lookup to read the reference on the stack before it can use it. The extra indirection applies for invoke2(ptr) too. In all other cases, the address to the function is sent directly to the invoke1/invoke2 function and does not need any extra indirection.

This example shows one interesting difference between a function reference and a function pointer.

Of course, compiler optimisation such as inlining could easily get rid of this extra indirection.