了解具有不同签名的继承和功能

Question

Say I have a base class and a derived class.

class Base {
 public:
  void A(int x, int y) {do something}
  void B() {
    A(x,y);
    do something;
  }
};

class Derived : public Base {
  void A() {do something else};
};

Derived derived1;
derived1.B();

The signatures of the functions are different, will the B call the derived A or the base A? Iif it will call the derived B, I guess it will dismiss the parameters?

what if the derived A needed different parameters rather than no parameters, would I have to copy B's entire code into the derived class just to change the way B calls A?

Answer 1

A function's code is always evaluated in the context of the class in which it is defined. This includes determining which function each expression calls. So inside Base::B() , the call A(x, y) is translated by the compiler as a call to Base::A . Even if you later call derived1.B() , it will call derived1 . Base::A derived1 . Base::A (pseudo-syntax).

The only thing which changes this slightly is virtual functions. However, even with them, the rules are similar. Overload resolution (which is basically the process of matching a function name & signature to a call expression) is done in the context of the class where the containing function is defined. If the resolution leads to a virtual function being selected, the virtual call mechanism will then be invoked at runtime to call the appropriate override of that function.

Let's consider this example:

struct Base {
  virtual void foo(int);
  virtual void bar() { foo(0.0); }
};

struct Derived : Base {
  virtual void foo(int);
  virtual void foo(double);
};

Derived d;
d.bar();

Even in this example, calling d.bar() will call Derived::foo(int) . That's because the call-to-signature matching was done in the context of Base , which only sees foo(int) and employs the implicit conversion from double to int.

Answer 2

Two reasons force Base::B to call Base::A not Derived::A

• It's calling A with specific overload: A(int, int)
• Base::A and Base::B are not virtual, so it calls Base::A . The code is not polymorphic.

The simplest example to show a how a virtual method works is:

class Base {
public:
   virtual void A() {
      // do job #1
   }
};

class Derived : public Base {
public:
   virtual void A() {
      // do job #2
   }
};

// ...

Derived derived1;

Base *base = &derived1;

base->A(); // <---- It calls `Derived::A()` and does job #2

But, if you write A in B with different parameter (overload it), you have to call it explicitly with actual arguments.