 <p>The lambda solution would be the idomatic C++11 way:</p> <pre><code>auto a = [&amp;]( int x ){ return superComplexAlgorithm( 3, 4, 5, x ); }; for( unsigned int i = 0; i &lt; 100; ++i ) do_stuff_with( a ); </code></pre> <p>The advantage of using a hand written functor is that you can:</p> <ol> <li>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 <code>bind</code>)</li> <li>It has a non-anonymous type (so you can talk about the type without using <code>auto</code>) -- the same is true of <code>bind</code>, but it also has a non-anonymous <em>meaningful</em> type you can get at without <code>decltype</code>ing the entire expression! C++1y again makes this better for <code>bind</code>/lambda.</li> <li>You can do perfect forwarding of the remaining arguments (you might be able to do this in C++1y with a lambda, and <code>bind</code> does this)</li> <li>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.</li> </ol> <p>You can also do some extremely powerful things with hand written functors that are impossible to do with <code>bind</code> 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.</p>