Re: Overloading template functions
On May 16, 3:11 pm, Zeppe
<zeppe@.remove.all.this.long.comment.email.it> wrote:
mattias.niss...@googlemail.com wrote:
Here is a problem I ran into at work. The following example doesn't
compile on gcc-4.1:
struct cons_end {};
template<typename U,typename V> struct cons {
U elem;
V tail;
};
at least, declare the function that you want to call before calling it:
template<typename U>
void foo4(U elem, cons_end tail);
IMHO, it is generally a good idea to declare functions before
use. For the reader, even in cases where the compiler doesn't
need it.
template<typename U, typename V>
void foo4(U elem, V tail)
{
::foo4(tail.elem,tail.tail);
}
you want the one argument template function to be called, but you
haven't declared it. At this point, ::foo4 refers to the only declared
(and defined) one, that is that one with two templates argument.
I'm not sure; this is one of the more complicated aspects of
C++. But as I understand it, the problem is that the :: in
front of foo prevent the lookup from being dependent, so name
binding occurs at the point of definition. Since in this case,
the author probably wants dependent lookup (which takes place at
the point of instantiation), he should in any case drop the ::,
which are typically used to tell the compiler *not* to consider
anything not yet visible.
(In this particular case, I still think it would be clearer to
declare the function before use. But I'd also drop the ::,
because I think dependant name lookup for foo4 is really what is
wanted.)
template<typename U>
void foo4(U elem, cons_end tail)
{
}
int main()
{
typedef cons<int,cons<int,cons_end> > tList;
tList list;
foo4(list.elem,list.tail);
return 0;
}
If I change the order of the definitions like so...
... the code compiles, the cons_end version of foo4 is selected.
because now the overloaded function is defined at the point in which is
called.
And because that definition is also a declaration---all that is
necessary, of course, is that a declaration be visible.
It's important to realize, though, that even though the function
is a template, name lookup does NOT depend on the instantiation
types, and occurs at the point of definition of the template, if
the name isn't dependent, and that using :: is one way to ensure
that the name isn't dependent.
--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34