Thread: ambiguous overload with derived classes?

basically, I have something like this:

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( foo( ), foo( ) ); // fine
      bar( 1024, foo( ) ); // fine
      bar( foo( ), 1024 ); // fine
      bar( baz( ), baz( ) ); // error: ambiguous overload
      bar( 1024, baz( ) ); // fine
      bar( baz( ), 1024 ); // fine
 
}

it's really not clear to me why the compiler doesn't choose bar( foo const &, foo const & ) as the closest match. is there a workaround for this, or will I have to wait for c++0x to implement a 'where' clause?

bar( baz() , baz() ) models both of the templates and the regular bar() function.
I can't see a way to explicitly specify which version of bar() you want, but one solution is to make just one template, but with default arguments. Since function templates can't have default arguments, you would have to use a function object, which may be stylistically distasteful:

Code:

template<typename Lhs = const struct foo&, typename Rhs = const struct foo&>
struct bar
{
   void operator() (Lhs arg1, Rhs arg2) { /* ... */ }
};

/* ... */
bar<>()( baz(), baz() );
/* Implicit conversion of 'const struct baz' to 'const struct foo&' */

It's likely that there's a much simpler solution.

well, among other things complicating the matter, 'bar' is actually an overloaded operator, so that won't work. but thanks for the suggestion anyway.