std::function is a new template added on C++11 that provides a versatile callable object wrapper: in a nutshell it can wrap around any kind of callable target, e.g., functions, non-static methods, objects with the call operator, and, naturally, lambda functions (which are either a function or an object with the () operator, anyway). 

Declaring and using a wrapper is quite simple:

 C++ | 
 copy code |
?
 
01
#include <math.h>
02
#include <iostream>
03
#include <functional>
04
 
05
struct SExample
06
{
07
    double operator()(double a, double b) { return a - b; }
08
};
09
 
10
int main(int, char **) 
11
{
12
    std::function<double(double, double)> fn; 
13
    SExample obj;
14
 
15
    fn = &pow;
16
    std::cout << fn(4, 4) << std::endl; // outputs 256
17
 
18
    fn = obj;
19
    std::cout << fn(4, 4) << std::endl; // outputs 0
20
 
21
    double x = 650;
22
    fn = [&] (double a, double b) -> double { return x + a * b; };
23
    std::cout << fn(4, 4) << std::endl; // outputs 666
24
}

As we can see, they behave quite closely to function pointers, but with a neater syntax and the advantage of accepting pretty much anything.

One interesting feature is that if the first parameter’s type is a class/struct,  the wrapper can be bound to a method of it,  so std::function will accept either functions/fuctors that match this signature, or pointers to a method of SExample that received a reference to a std::string, and returns a boolean, as we can see on the example below.

 C++ | 
 copy code |
?
 
01
#include <math.h>
02
#include <iostream>
03
#include <functional>
04
 
05
struct SExample
06
{
07
    bool HandleCommand(const std::string& _rCommand)
08
    {   
09
        std::cout << "SExample::HandleCommand: " << _rCommand << std::endl;
10
        return true;
11
    }   
12
};
13
 
14
bool HandleCommand(SExample &, const std::string &_rCommand)
15
{
16
    std::cout << "::HandleCommand " << _rCommand << std::endl;
17
    return true;
18
}
19
 
20
int main(int, char **) 
21
{
22
    std::function<bool(SExample &, const std::string &)> fn; 
23
    SExample obj;
24
 
25
    fn = &HandleCommand;
26
    fn(obj, "rehash");&nbsp;// outputs "::HandleCommand rehash"
27
 
28
    fn = &SExample::HandleCommand;
29
    fn(obj, "rehash"); // outputs "SExample::HandleCommand: rehash"
30
}

Internally this is achieved by some template trickery, where the function’s first parameter’s type is separated from the other arguments, so the assignment operator can accept a member function. Naturally this doesn’t apply to static methods, which are functions with slightly different scoping/access rules.

You can check if an object is bound to a function by checking comparing it to NULL/nullptr, or simply using it as a boolean (it has an implicit cast operator defined).