I always thought that f(type0) and f(type1) would resolve to different 
function calls when the two parameter types are unrelated.  I've run 
into a situation where that's definitely come into doubt.

Consider:

struct type0 {};
struct type1 {};

struct base0 { virtual int get(type0) const = 0; };
struct base1 { virtual double get(type1) const = 0; };

struct test_object_ : base0,base1 {};
struct test_object : test_object_
{
   int get(type0) const { return 5; }
   double get(type1) const { return 42.666; }
};

int main()
{
   test_object o;
   test_object_ * op = &o;

   int x = o.get(type0()); // OK by both VS2010 and Comeau
   int y = op->get(type0()); // ambiguous call to get in both.
}

After the ambiguous call error I also get an error about not being able 
to convert type0 to type1 when using VS2010.

I realize name resolution happens earlier than parameter resolution so 
both get() functions are viable names before the type is applied, but 
once type is applied get(type1) should become non-viable and be 
discarded.  This isn't happening through the pointer even though both 
the pointer and the static type have the same set of functions.

Can anyone explain why this is so?

-- 
http://crazycpp.wordpress.com

On 3/28/2011 10:12 AM, Noah Roberts wrote:

> Can anyone explain why this is so?
>

I can.  10.2 explains how member name lookup works and if the name 
refers to members of unrelated sub-objects that are not hidden, the 
program is ill-formed.  Parameter overload resolution can't then resolve 
ambiguity and there's an example showing such in 10.2/3.

Boo.

-- 
http://crazycpp.wordpress.com