Re: template matching
Ben Craig wrote:
On Feb 9, 12:44 pm, "James Kanze" <james.ka...@gmail.com> wrote:
The only
workaround I know of is to use helper functions, overloaded on
an additional parameter. Something like:
template< typename T >
void foo2( T const& ... ) { std::cout << "a" ; }
template< typename T >
void foo2( T const&, Base const& ) { std::cout << "b" ; }
template< typename T >
void foo( T const& obj ) { foo2( obj, obj ) ; }
In this case, when instantiating foo, the compiler will generate
implicit specializations for both instances of foo2, and add
them both to the overload set. And of course, the reference
initialization beats ... every time.
GCC complains violently (and sometimes crashes) when you pass non-PODs
through ellipses (...), even if you don't use the parameters passed
through them.
Good point. I think it's undefined behavior.
I find it more portable to rely on volatile const void
* as a fall-through case for that reason.
You can still use the ..., once you've got the pointer.
Just replace the call in foo with "foo2( obj, &obj )". I
like the ... because I never use them otherwise; if I see
.... at the end of a parameter list, I know that it is for
some sort meta-programming differentiation. But the
difference is purely one of style---it's not like my code is
chock full of volatile const void*'s either:-).
However, ellipses work just
fine if you never actually call the function, as is the case with some
metaprogramming sizeof tricks.
Which is doubtlessly where I learned the trick:-).
--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]