在派生类中重载基类方法

Question

I am trying to understand why the following code does not compile, apparently the solution relies in specifically declaring the dependency on method_A in the derived class. Please refer to the following code:

class Base
{
  public:

    void method_A(int param, int param2)
    {
      std::cout << "Base call A" << std::endl;
    }

};

//does not compile
class Derived : public Base
{
  public:

    void method_A(int param)
    {
      std::cout << "Derived call A" << std::endl;
    }
};

//compiles
class Derived2 : public Base
{
  public:
    using Base::method_A; //compile
    void method_A(int param)
    {
      std::cout << "Derived call A" << std::endl;
    }
};

int main ()
{
  Derived myDerived;
  myDerived.method_A(1);
  myDerived.method_A(1,2);

  Derived2 myDerived2;
  myDerived2.method_A(1);
  myDerived2.method_A(1,2);
  return 0;
}

"test.cpp", (S) The wrong number of arguments have been specified for "Derived::method_A(int)".

What is the technical reason that prevents the derived class to know its base class is implementing the method it's trying to overload? I am looking in understanding better how the compiler/linker behaves in this case.

Answer 1

Its called Name Hiding. When you define a non virtual method with the same name as Base method it hides the Base class method in Derived class so you are getting the error for

 myDerived.method_A(1,2);

To avoid hiding of Base class methods in Derived class use using keyword as you did in Derived2 class.

Also if you want to make it work you can do it explictly

myDerived.Base::method_A(1,2);

Check out this for better explanation why name hiding came into picture.

Answer 2

Well, for one you're calling

 myDerived.method_A(1,2);

with 2 arguments, whereas both in base and derived the method is declared to take only one argument.

Secodnly, you're not overriding anything, because method_A is not virtual. You're overloading.

Answer 3

If your intention is to override void Base::method_A(int param, int param2) then you should mark it virtual in the base class:

 virtual void method_A(int param, int param2)

Any function overriding this must have the same parameters and almost the same return type ('almost' loosely meaning that the differing return types must be polymorphically related, but in most cases it should have the identical return type).

All you're currently doing is overloading the function in the base class. The using keyword is bringing the base class function into the child class' namespace, as the language behaviour is not to do this by default.