创建一个带有状态的C ++ 11 std :: function <>

Question

what is the best way to create a C++11 std::function<> with state?

In plain C++98, I would create a functor struct that inherited from std::unary_function<> or std::binary_function<> . So given the following functor, how do I create a std::function<int(int)> from the following functor?

struct Functor
{
    int x;
    Functor(int val) : x(val) {}

    int operator()(int val) { return val + x; }
};

int main()
{
    Functor f(10);
    int x = f(30);
}

Note that the code above is a great simplification of what I need. Actually, the functor is configured with multiple parameters and reads data from a file (where each record is more complex than an int). Is there a solution that is closer to using functors than using lambdas?

Edit : Clarification

Answer 1

Easiest to use a lambda expression for this:

std::function<int(int)> f = [](int n) { return n + 30; }

You can also use std::bind :

std::function<int(int)> f = std::bind(std::plus<int>, std::placeholders::_1, 30);

In both cases, the 30 is just an example that could be replaced by a captured variable (make sure to change the capture specification in the lambda to [=] , though), and you would be better off using type auto to avoid a potentially expensive creation of a function object when you only need some callable type.

Answer 2

Use Lambdas:

 int x = 0;
 std::function<int (int)> add = [x](int val) { return  x + val; }
 auto add2 = [x](int val) { return  x + val; }

Here, the variables the lambda has access to are in the square brackets. x is passed as a copy. You can also pass a state as a reference by prefixing it with an '&' and capture 'this'

Answer 3

You can continue to use functors and classes in C++11, and in fact std::bind and std::function are now part of the C++11 standard, whereas previously they were part of the boost library and supported in tr1 or as extensions by various standard libraries. (Not compilers, they compiled already by the C++98/03 standard, but they were added as a library feature).

Lambdas are a new language feature, which are very useful when you really want a 1 or 2 line expression in an algorithm like sort or remove_if where a loop is inappropriate.

In your case, whilst you can write it with a lambda, if your logic is as complex as you make out, you probably don't want to use one in this instance for the sake of breaking up the logic of your code. You might still use a lambda to create a std::function out of this.

You might possibly even want to go down the even older "school" of using polymorphism here, ie passing in an object that has a function with a signature, and use that as the callback. It will certainly be easier to maintain the lifetimes of any objects this way.

Now, let's assume your object wants a callback function which essentially takes an int parameter somewhere and returns an int.

std::bind

What bind does is actually add extra parameters to a function, but that function must return an int. What it can do is be a class member function or take extra parameters.

If it is a class member you need an object to call it on.

std::bind( &MyClass::myFunction, myClassInstance, a, std::placeholders::_1 , b);

myClassInstance can be a reference-wrapper or pass-by-value or a pointer or a std::shared_ptr or std::unique_ptr of an object to your type. A reference-wrapper is a special class that contains a reference due to the fact that automatic template deduction will not be able to know whether you actually want to be passing a reference or by-value. Be careful of using reference-wrappers. The reference must still be valid at the point the function is called, and many hard-to-find bugs have occurred this way. In fact in its early days I rejected using bind and callbacks but it was so hard to trace bugs like these.

The placeholders::_1 tells the std::function where to put the int parameter it is passing. As I said, it can take extra parameters, but one of them will be your int. Essentially it means "put your int value here". a and b there are other parameters that need to be passed into this function and are supplied by the binder.

Lambdas

Lambdas do provide an alternative syntax to your bind in that you will actually invoke the call to your function in there. I am assuming that, given the complexity, you are going to write a function and a class somewhere and you just want to use a lambda to bind the callback to it.

In that case, you put in the square brackets of your lambda what is known as its "captures". These are like the other parameters of your bind.

std::function< int(int) > myFunc = [ &myClassInstance, a, b ]( int x )
{
    return myClassInstance.myFunction( a, x, b );
};

The captures here say that myClassInstance is a reference but the other two are by value. See http://en.cppreference.com/w/cpp/language/lambda for information about capture syntax.