Question

我正在摆弄虚拟方法的正确覆盖。我链接了一些构造函数，在基类构造函数中我调用了一个虚方法。

呼叫链应如下：

B(p)->A(p)->B.foo(p)

调用链在C ++中：

B(p)->A(p)->A.foo(p)

呼叫链在C＃中：

B(p)->A(p)->B.foo(p)

换句话说，在C＃中，行为与预期的一样，在C ++中它不是。

C ++代码：

#include <cstdio>

class A {
public:
  A();
  A(int);

  virtual void foo(int s);
};

class B : public A {
public:
  B();
  B(int s) : A(s) {};

  virtual void foo(int s) override;
};

A::A() {
  std::printf("A\r\n");
};

A::A(int s) : A() {
  std::printf("A: %d\r\n", s);
  foo(s);
};

void A::foo(int s) {
  std::printf("A::foo(%d)\r\n", s);
}

B::B() : A(){
  std::printf("B\r\n");
};

void B::foo(int s) {
  std::printf("B::foo(%d)\r\n", s);
}

int main(int argc, char* argv[]) {
  B b(2);
}

输出：

A
A: 2
A::foo(2)

C＃代码：

using System;

namespace demo {
class A{
  public A() {
    Console.WriteLine("A");
  }

  public A(int s) : this(){
    Console.WriteLine("A: " + s.ToString());
    foo(s);
  }

  public virtual void foo(int s) {
    Console.WriteLine(string.Format("A:foo({0})", s));
  }
}

class B : A{
  public B() : base() {
    Console.WriteLine("B");
  }

  public B(int s) : base(s) {
  }

  public override void foo(int s) {
    Console.WriteLine(string.Format("B:foo({0})", s));
  }
}

  static class Run {
    static void Main() {
      new B(2);
    }
  }
}

输出：

A
A: 2
B::foo(2)

为什么不在C ++中调用B类的重写方法？我该如何正确覆盖它？

Answer 1

这就是C ++的工作方式。虚拟函数在对象构造和破坏期间不会表现得很虚伪。

C ++虚方法未按预期调用

1 个答案: