C++ overload resolution [duplicate]

Question

Given the following example, why do I have to explicitly use the statement b->A::DoSomething() rather than just b->DoSomething()?

Shouldn't the compiler's overload resolution figure out which method I'm talking about?

I'm using Microsoft VS 2005. (Note: using virtual doesn't help in this case.)

class A {   public:     int DoSomething() {return 0;}; };  class B : public A {   public:     int DoSomething(int x) {return 1;}; };  int main() {   B* b = new B();   b->A::DoSomething();    //Why this?   //b->DoSomething();    //Why not this? (Gives compiler error.)   delete b;   return 0; } 

Answer 1

The two “overloads” aren't in the same scope. By default, the compiler only considers the smallest possible name scope until it finds a name match. Argument matching is done afterwards. In your case this means that the compiler sees B::DoSomething. It then tries to match the argument list, which fails.

One solution would be to pull down the overload from A into B's scope:

class B : public A { public:     using A::DoSomething;     // … } 

Answer 2

Overload resolution is one of the ugliest parts of C++

Basically the compiler finds a name match "DoSomething(int)" in the scope of B, sees the parameters don't match, and stops with an error.

It can be overcome by using the A::DoSomething in class B

class A   {     public:       int DoSomething() {return 0;} };    class B : public A   {     public:       using A::DoSomething;     int DoSomething(int x) {return 1;}  };      int main(int argc, char** argv) {   B* b = new B();     // b->A::DoSomething();    // still works, but...   b->DoSomething();    // works now too   delete b;     return 0; }