Peter Dimov wrote:
On a reasonably conforming compiler, adding an overload to apply<>
should work:
template
result_type operator()
(F & f, A1 & a1, A2 & a2, A3 & a3) const
{
return f(a1, a2, a3);
}
// add this
template
result_type operator()
(M T::* pm, A1 & a1, A2 & a2, A3 & a3) const
{
return mem_fn(pm)(a1, a2, a3);
}
It might be a good idea to add this to apply.hpp, but I would need to
write a test for apply<> first.
Sorry for the incomplete previous post. What I meant to say was ...
That looks very interesting. And if I augment my previous code with
your suggestion I get the result below. Except for the obvious (and
expected) difference of needing to pass an instance of the class in
question, the member function and non-member function uses of apply look
identical. Very nice.
Dave
#include <vector>
#include <iostream>
#include <iterator>
#include "boost/bind.hpp"
namespace boost
{
template<class R> struct apply
{
typedef R result_type;
template
result_type operator()
(M T::* pm, A1 & a1, A2 & a2, A3 & a3) const
{
return mem_fn(pm)(a1, a2, a3);
}
template
result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
{
return boost::mem_fn(f)(a1, a2, a3);
}
template
result_type operator()(F & f, A1 & a1, A2 & a2) const
{
return f(a1, a2);
}
};
} // namespace boost
using namespace std;
using namespace boost;
struct A {
float a(int m, float x) { return m * x;}
float b(int m, float x) { return m + x;}
float c(int m, float x) { return m - x;}
float d(int m, float x) { return m / x;}
};
float a2(int m, float x) { return m * x;}
float b2(int m, float x) { return m + x;}
float c2(int m, float x) { return m - x;}
float d2(int m, float x) { return m / x;}
typedef float (A::*pfn)(int, float);
typedef float (*pfn2)(int, float);
int
main()
{
A a;
int m = 2;
float x = 3.0;
vector<pfn> v;
vector<pfn2> v2;
vector<float> f;
v.push_back(&A::a);
v.push_back(&A::b);
v.push_back(&A::c);
v.push_back(&A::d);
v2.push_back(&a2);
v2.push_back(&b2);
v2.push_back(&c2);
v2.push_back(&d2);
transform(v.begin(), v.end(), back_inserter(f),
bind(apply<float>(), _1, a, m, x));
transform(v2.begin(), v2.end(), back_inserter(f),
bind(apply<float>(), _1, m, x));
copy(f.begin(), f.end(), ostream_iterator<float>(cout, "\n"));
}
