The STL provides the useful std::for_each, and std::transform algorithms, which make it easy to iterate over sequences without needing to write a loop. They’re especially useful when you’re using existing free functions, static functions, and member functions:

// If v contains MyClass objects
std::for_each(v.begin(), v.end(), &FreeFunction);
std::for_each(v.begin(), v.end(), &MyClass::StaticFunction);
std::for_each(v.begin(), v.end(), std::mem_fun_ref(&MyClass::MemberFunction));

// If v contains pointers to MyClass objects
std::for_each(v.begin(), v.end(), std::mem_fun(&MyClass::MemberFunction));

Often however, there isn’t an existing function to do what you want, and you end up defining a function or function object just where you use it:

namespace {
    struct FunctionObject {
        void operator()(MyClass& m) {
            // Do something to m here
        }
    };
};

std::for_each(v.begin(), v.end(), FunctionObject());

Things can get more awkward still when you have local variables that you want to use in the operation you’re performing:

namespace {
    struct FunctionObject2 {
        typedef MyClass first_argument_type;
        typedef int second_argument_type;
        typedef void result_type;
        void operator()(const MyClass& m, int x) const 
        {
            // Do something with m and x here
        }
    };
};

int x;
std::for_each(v.begin(), v.end(), std::bind2nd(FunctionObject2(), x));

This is rather complicated for a one-shot piece of code. It would be much better to be able to define the operation to be performed in-line at the point of use, and this is what lambda expressions allow you to do.

For example, this lambda expression replaces our first example:

std::for_each(v.begin(), v.end(), [](MyClass& m) { /* Do something to m here*/ });

The [] can capture local variables, making them available within the body of the lambda expression. This is how our second example would look:

int x;
std::for_each(v.begin(), v.end(), [x](MyClass& m) { /* Do something with m and x here*/ });