iterating over a std::map using boost::bind - c++

Question

I have made a small example in order to understand how boost::bind () works with collections. I have a class called Data:
class Data
{
public:
void print ();
const std::string& get () const;
std::string& get () ;
};
I have created a std::vector of Data objects called samples and I am able to use bind in the same way as std::mem_fun_ref works.
std::for_each (samples.begin (),samples.end (),std::mem_fun_ref (&Data::print));
std::for_each (samples.begin (),samples.end (),boost::bind (&Data::print,_1));
The basic idea is that the bind returns a function object of type bind_t<RetType=void, ObjType=Data, ArgType=void>. The member function as the first parameter allows the compiler to deduce RetType, ObjType and ArgType. The placeholder _1 corresponds to the data object which must be provided by the algorithm.
Then std::for_each calls the function object "for each" element in the following way:
for ( ; first!=last; ++first ) f(*first);
bind_t::operator(ObjType& obj) is invoked and its definition should be something like this:
return (obj.*_method ());
I have crated a class called Filter that performs some processing over a data element.
class Filter
{
void filter (Data& data);
...
};
If I want to apply the filter over the data elements in the vector I call bind in the following way:
std::for_each (samples.begin (),samples.end (),boost::bind (&Filter::filter,filter,_1));
for_each passes a Data object to bind_t::operator(). In this case the function object already has the object and just need the parameter so in this case placeholder _1 refers to the argument.
Here comes my question:
How can use bind if I have to iterate over a std::map rather than a vector?
(Sorry for all the explanation, I just want to make sure that I understand the way in which bind works)

Answer 1

#include <boost/bind.hpp>
#include <algorithm>
int main()
{
struct Sample
{
int i_;
double d_;
};
typedef std::map<int, Sample> Samples;
struct Filter
{
void filter(const Sample &s)
{
}
};
Filter filter;
Samples samples;
std::for_each(samples.begin(), samples.end(), boost::bind(&Filter::filter, filter, boost::bind(&Samples::value_type::second, _1)));
}

Answer 2

Of course, you can use bind() to iterate over a std::map<...>. However, note that the elements in the std::map<K, V> have the type std::pair<K const, V> i.e. the bound function needs to be cable of accessing objects of this type. That said, I'm not aware that bind() alone can be used to transform this argument into the argument you are actually interested (i.e. to a V). To do this, you probably need an auxiliary function which is called to do the transformation. If you bind() this function as well bind() can do a suitable composition, i.e. I think something like this should work:
template <typename Result>
struct project2nd {
typedef Result const& result_type;
template <typename T>
result_type operator()(std::pair<T, Result> const& arg) const {
return arg.second;
}
};
...
... bind(&Filter::filter, filter, bind(project2nd<Data>(), _1)) ...
For bind() to work with a funciton object it seems it needs some information about related types: the result of the function call operator can't be deduced but is apparently needed internally. I assume that bind() is clever enough to pass references through. Otherwise the type needs to be changed to be Result. Also, I don't know if bind() also needs to know about the argumen type. If so, the project2nd class tmeplate would need to take both types as argument.