The lambda solution would be the idomatic C++11 way:
auto a = [&]( int x ){ return superComplexAlgorithm( 3, 4, 5, x ); };
for( unsigned int i = 0; i < 100; ++i )
do_stuff_with( a );
The advantage of using a hand written functor is that you can:
- Move arguments into the capture, or transform them (you can do that with lambda in C++1y, but not yet -- this is also possible with
bind
) - It has a non-anonymous type (so you can talk about the type without using
auto
) -- the same is true ofbind
, but it also has a non-anonymous meaningful type you can get at withoutdecltype
ing the entire expression! C++1y again makes this better forbind
/lambda. - You can do perfect forwarding of the remaining arguments (you might be able to do this in C++1y with a lambda, and
bind
does this) - You can mess around with how the captured data is stored (in a pointer? a smart pointer?) without messing up the code where you create the instance.
You can also do some extremely powerful things with hand written functors that are impossible to do with bind
and lambdas, like wrap an overload set of multiple functions into one object (that may or may not share a name), but that kind of corner case isn't going to show up often.