Re: ambiguous overload when used with derived classes?
On May 24, 4:38 am, Greg Herlihy <gre...@mac.com> wrote:
On May 23, 2:01 pm, James Kanze <james.ka...@gmail.com> wrote:
On 23 mai, 06:29, sebastian <sebastianga...@gmail.com> wrote:
[code]
struct foo
{ };
void
bar( foo const & lhs, foo const & rhs )
{ }
template < typename Lhs >
void
bar( Lhs const & lhs, foo const & rhs )
{ }
template < typename Rhs >
void
bar( foo const & lhs, Rhs const & rhs )
{ }
struct baz : foo
{ };
int
main( void )
{
bar( baz( ), baz( ) ); // error: ambiguous overload
}
[/code]
I thought that the compiler would deduce bar( foo const &, foo
const & ).
Why? The compiler has to choose between three functions:
void bar( foo const&, foo const& ) ;
void bar( baz cosnt&, foo const& ) ;
void bar( foo const&, baz const& ) ;
Note the second and third bar() functins are actually function
template "specializations", so it would be more accurate to present
the three bar() candidate functions as:
void bar( foo const&, foo const& ) ;
template <>
void bar<baz>( baz cosnt&, foo const& ) ;
template <>
void bar<baz>( foo const&, baz const& ) ;
True, but that doesn't change anything. A template
specialization is no longer a template (and of course, only the
specializations play a role in overload resolution).
For the first argument, the second function is the best
match, and for the second, the last function. How can the
compiler decide?
Presumably in the same way that the C++ compiler would choose
the best bar() overload - if there were only the first bar()
functions from which to choose. In other words, once the third
bar() function is eliminated, the call to bar() is no longer
ambiguous.
No, but if I understand correctly, the resolution isn't the one
the original poster wanted. Basically, he doesn't want the
templates to be considered if the non-template version can be
called, or at least, he wants the template versions to be
ignored if the type derives from bar.
There is no ambiguity because - when the compiler
has to choose between between:
void bar( foo const&, foo const& ) ;
template <>
void bar<baz>( baz cosnt&, foo const& ) ;
the C++ compiler will - all other things being equal - prefer
the non- template function over the template function.
But all other things aren't equal here. In the second version,
the first argument is an exact match, where as in the second,
there is a derived to base conversion. So the second function
is a better match for the first argument, both functions are
equal for the second, and the compiler chooses the second
function.
So what makes this example interesting (and in fact
counterintuitive), is that the C++ compiler finds the call to
bar() "ambiguous" - even though one of the three bar()
candidates is considered a better match (being the only
non-template function candidate) than the other two.
The rule to prefer a non-template function only comes into play
when there are no arguments for which one function is a better
match. That's not the case here.
Or to put it another way, why is the non-template function a
better match than one other template function candidate - but
not a better match than two other template function
candidates?
Because both of the template functions are better matches for at
least one argument. See =A713.3.3:
Given these definitions, a viable function F1 is defined
to be a better function than another viable function F2
if for all arguments i, ICSi(F1) is not a worse
conversion sequence than ICSi(F2), and then
-- for some argument j, ICSj(F1) is a better conversion
sequence than ICSj(F2), or, if not that,
-- F1 is a non-template function and F2 is a function
template specialization, or, if not that,
[...]
The first point holds, so we don't even get to the second.
--
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