Is there a use case for std::function that is not covered by function pointers, or is it just syntactic sugar? [duplicate]

Answer 1

std::function is designed to represent any kind of callable object. There are plenty of callable objects that cannot be represented in any way by a function pointer.

1. A functor:

   struct foo {
     bool operator()(int x) { return x > 5; }
   };
   
   bool (*f1)(int) = foo(); // Error
   std::function<bool(int)> f2 = foo(); // Okay
   

   You cannot create an instance of foo and store it in a bool(*)(int) function pointer.

2. A lambda with a lambda-capture:

   bool (*f1)(int) = [&](int x) { return x > y; }; // Error
   std::function<bool(int)> f2 = [&](int x) { return x > y; }; // Okay
   

   However, a lambda without a capture can be converted to a function pointer:

   The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as the closure type’s function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type’s function call operator.

3. Implementation-defined callable return values:

   bool foo(int x, int y) { return x > y; };
   
   bool (*f1)(int) = std::bind(&foo, std::placeholders::_1, 5); // Error (probably)
   std::function<bool(int)> f2 = std::bind(&foo, std::placeholders::_1, 5); // Okay
   

   std::bind's return value is an implementation-defined callable object. Only how that object may be used is specified by the standard, not its type.

Answer 2

std::function<> gives you the possibility of encapsulating any type of callable object, which is something function pointers cannot do (although it is true that non-capturing lambdas can be converted to function pointers).

To give you an idea of the kind of flexibility it allows you to achieve:

#include <functional>
#include <iostream>
#include <vector>

// A functor... (could even have state!)
struct X
{
    void operator () () { std::cout << "Functor!" << std::endl; }
};

// A regular function...
void bar()
{
    std::cout << "Function" << std::endl;
}

// A regular function with one argument that will be bound...
void foo(int x)
{
    std::cout << "Bound Function " << x << "!" << std::endl;
}

int main()
{
    // Heterogenous collection of callable objects
    std::vector<std::function<void()>> functions;

    // Fill in the container...
    functions.push_back(X());
    functions.push_back(bar);
    functions.push_back(std::bind(foo, 42));

    // And a add a lambda defined in-place as well...
    functions.push_back([] () { std::cout << "Lambda!" << std::endl; });

    // Now call them all!
    for (auto& f : functions)
    {
        f(); // Same interface for all kinds of callable object...
    }
}

As usual, see a live example here. Among other things, this allows you to realize the Command Pattern.