c++ - c++中动态调度的规则是什么？

Question

我想知道动态调度在 C++ 中究竟是如何工作的。为了说明我的问题，我将从一些 Java 代码开始。

class A
{
  public void op(int x, double y) { System.out.println("a"); }
  public void op(double x, double y) { System.out.println("b"); }
}

class B extends A
{
  public void op(int x, double y) { System.out.println("c"); }
  public void op(int x, int y) { System.out.println("d"); }
}

class C extends B
{
  public void op(int x, int y) { System.out.println("e"); }
}

public class Pol
{
  public static void main(String[] args)
  {
    A a = new C();
    B b = new C();

    /* 1 */ a.op(2, 4);
    /* 2 */ b.op(2.0, 4.0);
  }
}

调用 a.op(2, 4) 将打印“c”，因为确实是编译器:

• 查看类 A(因为 a 被声明为 A 类型的变量)哪个方法最接近 操作(整数，整数)，
• 找不到 op(int, int) 方法，但找到方法 op(int, double)(使用单个自动转换 int -> double),
• 然后修复这个签名。

在执行期间，JVM:

• 寻找具有签名op(int, double) 的方法，该方法已被编译器固定到类 C 中，但没有找到，
• 查看 C 的父类(super class)内部，即 B，
• 最后找到一个方法op(int, double)，然后调用它。

同样的原则适用于打印“b”的调用 b.op(2.0, 4.0)。

现在，考虑 C++ 中的等效代码

#include <iostream>

class A
{
public:
  virtual void op(int x, double y) { std::cout << "a" << std::endl; }
  virtual void op(double x, double y) { std::cout << "b" << std::endl; }
};

class B : public A
{
public:
  void op(int x, double y) { std::cout << "c" << std::endl; }
  virtual void op(int x, int y) { std::cout << "d" << std::endl; }
};

class C : public B
{
public:
  void op(int x, int y) { std::cout << "e" << std::endl; }
};

int main()
{
  A *a = new C;
  B *b = new C;

  /* 1 */ a->op(2,  4);
  /* 2 */ b->op(2.0, 4.0);

  delete a;
  delete b;
}

a->op(2, 4) 将像 Java 一样打印“c”。但是 b->op(2.0, 4.0) 再次输出“c”，我迷路了。

在 C++ 中动态调度在编译和执行期间应用的规则究竟是什么？(请注意，如果您在每个函数前面编写 virtual，您将拥有与 C++ 代码相同的行为；这里没有任何改变)

Answer 1

对于 C++，当您执行 b->op(2.0, 4.0); 时，编译器会在 B 中查找，找到它可以调用的方法 (int x, double y) 并使用它。如果子类中的任何方法可以处理调用，它不会在父类(super class)中查找。这称为方法隐藏，即。 op(double, double) 是隐藏的。

如果你想让它选择 (double x, double y) 版本，你需要在 B 中使用以下声明使函数可见 B:

using A::op;

Further explanation of the rules