What's going on with overriding and overloading here in C++?

Question

This doesn't work:

class Foo
{
public:
    virtual int A(int);
    virtual int A(int,int);
};
class Bar : public Foo
{
public:
    virtual int A(int);
};

Bar b;
int main()
{
    b.A(0,0);
}

It seems that by overriding Foo::A(int) with Bar::A(int) I have somehow hidden Foo::A(int,int). If I add a Bar::A(int,int) things work.

Does anyone have a link to a good description of what's going on here?

Answer 1

Essentially, name lookup happens before overload resolution so the function A in your derived class overrides the virtual function in the base class but hides all other functions with the same name in any base classes.

Possible solutions include adding a using Foo::A; directive into your derived class to make all the base class members called A visible in the derived class or using different names for functions with different signatures.

See here as well.

Answer 2

There's a discussion on there here: http://bojolais.livejournal.com/222428.html

The crux is: In C++, when you have a class with an overloaded method (member function, whatever you want to call it), and you then extend and override that method, you must override all of the overloaded method

A workaround is to change the call to:

b.Foo::A(0, 0);

Answer 3

The easiest way of thinking about this is to remember that overloading always occurs WITHIN a single scope, while overriding appears between scopes. When figuring out which function to call, the compiler FIRST looks to find the closest scope that has the the name and then resolves overloading between definitions in that scope.