Re: template function object for accumulate
er wrote:
On Sep 5, 7:33 am, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
er wrote:
On Sep 4, 1:55 pm, er <erwann.rog...@gmail.com> wrote:
hi, that's indeed what i needed. thank!
by the way, why does it work? is there a name for this?
I am sorry, you removed all context when you posted this,
why does *what* work? Is there name for *what*?
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
below is my code and your correction to overcome the possibility that
*Ff be a const member function, and it achieves that goal. it's just
not obvious to me how it works. if you or anyone else could explain a
little that would be nice. thanks!
//code that gen error: could not convert template argument
'&TestConst::get' to 'double (TestConst::*)()')
//but it works with Test
template<typename C,typename R,R (C::*F)()>
You specified the third argument too strictly. It prevents using
a member function declared 'const'. What I've suggested has no
such restriction.
class Accumulate_op_v1: public std::binary_function<R,C,R>{
public:
My_accumulate_op(){};
R operator()(R sum_so_far,C& obj)const;
};
template<typename C,typename R,R (C::*F)()>
R Accumulate_op_v1<C,R,F>::operator()(R sum_so_far,C& obj)const{
return sum_so_far+(obj.*F)();
};
//code that works with a const C&
template<typename C, typename R, typename Ff>
Here 'Ff' can be essentially /anything/. The only limitation
imposed on it comes from the use of 'F'. It has to be a member
of the 'C' type (since it's used through the 'obj' reference to
an object of type 'C'), and it has to be callable without any
arguments (since none are supplied in the expression).
class Accumulate_op_T {
Ff F;
public:
Accumulate_op_T(Ff f) : F(f) {}
R operator()(R sum_so_far, C& obj) const
{
return sum_so_far + (obj.*F)();
}
};
template<typename C, typename R, typename Ff>
Accumulate_op_T<C,R,Ff> Accumulate_op_v2(Ff f) {
The type 'Ff' is *deduced* from the argument you pass to this
funciton. The proper template is instantiated and the temporary
object is created and used. Since in this case you never have
to spell out what type 'Ff' is, it becomes possible to use the
code with either a const member function or a non-const one.
return Accumulate_op_T<C,R,Ff>(f);
}
//main
int main(){
Test t;
std::vector<Test> vec(3, t);
TestConst tc;
std::vector<TestConst> vecc(4, tc);
std::cout
<< std::accumulate(
vec.begin(),
vec.end(),
0.0,
Accumulate_op_v2<Test, long double>(&Test::get))
<< std::endl;
std::cout
<< std::accumulate(
vecc.begin(),
vecc.end(),
0.0,
Accumulate_op_v2<TestConst, long
double>(&TestConst::get))
<< std::endl;
return 0;
}
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask