C++ for Scientists - Technische Universität Dresden

210 CHAPTER 7. EFFECTIVE PROGRAMMING: THE POLYMORPHIC WAY
7.4.1 Lambda Calculus
As was presented in Section ref(), is not very easy to reuse the STL standard function objects
because the use is not very intuitive. Either a function object for each loop or binder has to be
written. A binder (or binder object) is passed at construction time, to another function object
which performs an action. The binder takes the function object as well as another binding value
and makes a binary function unary by fixing the first parameter. However it is not obvious at
first. An easy way to implemented such a functionality is to write it as it is:
std::for each(vec.begin(), vec.end(), std::cout ≪ ∗vec iter);
Of course this can not compile for several reasons. First the third argument is not a function
object. Second the variable vec iter does not exist, nor does it know anything about the
iterated container vec. Anyway, an expression like this is easy to write and less error prone
compared to a binder object. To enable a program like this the following has to be accomplised:
First the output-stream operator
ArgumentT
operator()(ArgumentT arg)
{
return arg1;
}
template< typename Argument1T, typename Argument2T>
ArgumentT
operator()(Argument1T arg1, Argument2T arg2)
{
return arg1;
}
};
So what does this object really do? It provides unary and binary bracket operators for one and
two objects which return the argument passed. A function object is implemented next which
stores an arbitrary stream type.
template
output function object
{
output function object (StreamType stream, FunctionObjectT func) : stream(stream), func(func) {}
template < typename ArgumentT>
void operator()(ArgumentT arg)
{