C++ 中的重写函数不起作用

Question

#include <cstdio>
using namespace std;

class A {
public:
    virtual void func() { printf("A::func()"); }
};

class B : public A {
public:
    virtual void func() { printf("B::func()"); }
};

int main() {
  A a = *(A *)new B();
  a.func();
}

问题很简单：为什么 a->func() 调用类 A 中的函数，即使 a 包含类 B 的对象？

Answer 1

A a = *(A *)new B();
a.func();

以下是此代码中逐步发生的情况：

• new B()：在空闲存储上分配 B 类型的新对象，产生其地址
• (A*) >：对象的地址被强制转换为A*，因此我们有一个A*类型的指针实际上指向B类型的对象，这是有效的。一切都好。
• A a：问题从这里开始。在堆栈上创建一个新的 A 类型本地对象，并使用复制构造函数 A::A(const A&) 构造，第一个参数是创建的对象前。
• 在此语句之后，指向类型 B 的原始对象的指针将丢失，从而导致内存泄漏，因为它是通过 new 分配到空闲存储上的。
• a.func() - 该方法在类 A 的（本地）对象上调用。

如果将代码更改为：

A& a = *( A*) new B();
a.func();

则只会构造一个对象，其指针将转换为输入A*，然后取消引用，并且将使用此地址初始化新的引用。虚函数的调用将被动态解析为B::func()。

---

但请记住，您仍然需要释放该对象，因为它是通过 new 分配的：

delete &a;

顺便说一句，只有当 A 有一个虚拟析构函数时，这才是正确的，而 B 需要这样： :~B() （幸运的是这里是空的，但在一般情况下不需要）也将被调用。如果 A 没有虚拟析构函数，那么您需要通过以下方式释放它：

delete (B*)&a;

---

如果您想使用指针，那么这与引用相同。代码：

A* a = new B(); // actually you don't need an explicit cast here.
a->func();
delete (B*)a; // or just delete a; if A has a virtual destructor.

Answer 2

现在您已经修改了代码片段，问题就清楚了。多态性（即虚函数）只能通过指针和引用来调用。这些你都没有。 A a = XXX 不包含 B 类型的对象，它包含 A 类型的对象。通过执行指针转换和取消引用，您已经“切掉”了对象的 B 性。

如果您执行 A *a = new B();，那么您将获得预期的行为。

Answer 3

您遇到的问题是经典的 对象切片 ：

A a = *(A *)new B();

使 a 要么指向 A 的引用或指针，虚拟调度将按您的预期工作。有关更多说明，请参阅这个其他问题。

---

您评论了另一个答案“编译器至少应该发出警告或什么”。这就是为什么将基类设置为抽象或不可复制被认为是一个好习惯：您的初始代码一开始就不会编译。

Answer 4

这也许可以做到这一点。

A &a = *(A *)new B();
a.func();

或者

A *a = new B();
a->func();

Answer 5

虚拟调度仅适用于指针或引用类型：

#include <cstdio>
using namespace std;

class A {
public:
  virtual void func() { printf("A::func()"); }
};

class B : public A {
public:
  virtual void func() { printf("B::func()"); }
};

int main() {
  A* a = new B();
  a->func();
}

Answer 6

问题是使用 A a = *(A *)new B(); 将 B 遵从并强制转换为 A；

您可以通过删除 *(A *) 将其更改为 (A *a = new B(); ) 来修复它，但我会更进一步，因为您的变量名不适合 B 的实例化。

它应该是

B *b = new B(); 
b->func(); 

Answer 7

因为当您将动态分配的对象复制到 A 类型的对象 a 时，您执行了切片（这也会导致内存泄漏）。

a 应该是一个引用 (A&)，或者只保留指针。