Where to put function called by for_each in a class? - c++

Question

With newer C++ features, you often give a function as a parameter, for example:
// File A.cpp
void do_something(Foo* foo) { ... }
void A::process_foo(){
for_each( foo_list.begin(), foo_list.end(), do_something );
}
But where should I actually put the function do_something(...) when I work with classes? I can not make it a private member, since I would loose this when passing the parameter to for_each.
So I tend to just define a plain function do_something(...) in my implementation file A.cpp, like given in the code above. Since this is visible by the implementation of A only, I do not risk namespace pollution. Since a similiar function in other classes would also only be visible in their implementation, I also do not risk to have a name collision with a similiar function of another class.
Is this the right way?
Another idea would be to use a Lambda. I'm not very familiar with Lambdas, so I don't know whether I should use them as much as possible or only if absolutely necessary...

Answer 1

The third argument of std::for_each needs to be function or function object with one argument such as it may be called with an element of the range defined by first two arguments of for_each. Then you have following options (assuming that foo_list stores Foo*):
Use regular function
void do_someting(Foo*){...}
for_each(..., do_something);
You can put the function wherever it is suitable. If this is for local use, the anonymous namespace is the best option. But it may be e.g. defined in a separate compilation unit.
Use static method
static void do_something(Foo*){...}
for_each(..., &Foo::do_something);
Note that it does not need necessarily to be static method of Foo.
Use lambda
for_each(...,[](Foo* f){...});
Use a method of Foo class (even private) and std::bind
void method(){...}
for_each(..., std::bind(&Foo::method, _1));
There are other options but those are the most common.

Answer 2

C++11 solution
If you can use C++11, prefer range-based for instead of std::for_each and just write code in-place. Like this:
for (const auto& value : foo_list)
{
// do something with the value
}
It is less verbose and more convenient. It iterates through all of the elements one by one, just like std::for_each algorithm. And you can explicitly specify that you don't want to modify elements by putting const auto&, or simply auto (without reference).
Partial-C++11
If your compiler has no support of range-based fors, but has support of lambdas (like Visual Studio 2010), simply put function into lambda:
for_each( foo_list.begin(), foo_list.end(),
[] (const FooList::value_type& value) { /* do something with the value */; });
C++98
If you can use none of the above C++11 features, most of STL algorithms look pathetic. Whichever you place do_something function to, it will be decoupled from the calling code, which is very hard to read. Prefer simple iterator-based for in this case:
for (FooList::iterator pValue = foo_list.begin(); pValue != foo_list.end(); ++pValue)
{
// do something with the pValue
}
PS I prefer the latter form even for "Partial-C++11" case, when you cannot use range-based fors, but can replace FooList::iterator with simple auto. It is very helpful when you would have to write something more complicated, like std::list<std::string>::const_iterator. I think the following is better than std::for_each with lambda:
for (auto pValue = foo_list.begin(); pValue != foo_list.end(); ++pValue)
{
// do something with the pValue
}