🚀 go-pugleaf

[Moderator's note: This article is crossposted between comp.std.c++
and comp.lang.c++, and followups have been set to comp.std.c++.  mha]

The following doesn't compile, because the calls to foo look ambiguous
to the compiler:

template<class T>
class Goo {
public:
    void foo(T *) {}
};

class A {
};

class B {
};

class C : public Goo<A>, public Goo<B> {
};

main() {
    A a;
    B b;
    C c;
    c.foo(&a);
    c.foo(&b);
}
    
Why is this? Why doesn't the mechanism that checks for which function to call
look at the function signature instead of just the name? I presume this is
related to the following:

class A {
public:
    void goo(A*) {}
};

class B : public A {
public:
    void goo(B*) {}
};

class C : public B {
};

main() {
   A a;
   B b;
   C c;
   c.goo(&a);
   c.goo(&b);
}

which won't compile because B::goo hides A::goo (even though again they
have different signatures). What's the interest of a having function hide
another with a totally different prototype simply because their names match?
Of course I can make these things compile by explicitly disambiguating in each 
case, but it's annoying and I can't think of any benefit to this behavior. Why 
does it work this way?


jah
---
[ comp.std.c++ is moderated.  To submit articles: Try just posting with your 
                newsreader.  If that fails, use mailto:std-c++@ncar.ucar.edu
  comp.std.c++ FAQ: http://reality.sgi.com/austern/std-c++/faq.html
  Moderation policy: http://reality.sgi.com/austern/std-c++/policy.html
  Comments? mailto:std-c++-request@ncar.ucar.edu 
]