Re: arrays decaying to pointers
On 30 Mai, 14:56, Marc wrote:
arrays decay to pointers, which allows for:
template<class Iter>
void f(Iter first, Iter theend);
int tab[]={1,2,3};
f(tab,tab+3);
and Iter is deduced as int*.
However, if I go through a forwarding function:
template<class A,class B>
void g(A const&a, B const&b){ f(a,b); }
g(tab,tab+3);
f now receives a reference to an array of _const_ int and a reference
to a const pointer to int. But just passing f a pointer to const
int and a pointer to int is already an error as the compiler can't
deduce Iter anymore
This behaviour is probably one reason why iterators are usually passed
by value. To manually force the decay I sometimes write things like
f(tab+0,tab+3);
:-)
So it looks like my best bet is to define f with 2 different template
parameters: [...]
I'd say, f is not the peoblem. It's fine the way it is. You have to
change g somehow. Either by use of perfect forwarding or just by
taking the parameters by value. After all, they're just iterators.
Iterators are expected to be small and cheaply copyable. If you don't
know what kind of parameters the function f expects (which might be
the case in generic code), this calls for perfect forwarding.
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]