virtual 关键字使派生对象无法访问方法

Question

我有这样的代码：

#include <iostream>

class Super{
public:
    virtual void showName();
};

class Special1 : public Super {
public:
    void showName();
    void sayHello();
};

class Special2 : public Super {
public:
    void showName();
    void sayGoodbye();
};

void Super::showName() {
    std::cout << "I'm super!" << std::endl;
}

void Special1::showName() {
    std::cout << "I'm special1" << std::endl;
}

void Special1::sayHello() {
    std::cout << "Hello" << std::endl;
}

void Special2::showName() {
    std::cout << "I'm special2" << std::endl;
}

void Special2::sayGoodbye() {
    std::cout << "Goodbye" << std::endl;
}

int main () {
    Super *oSpec=new Super;

    Special1 *o1=static_cast<Special1 *>(oSpec);
    Special2 *o2=static_cast<Special2 *>(oSpec);

    oSpec->showName();
    o1->showName();
    o2->showName();

    o1->sayHello();
    o2->sayGoodbye();

    delete oSpec;

    return 0;
}

当我运行它时，它会显示以下输出：

I'm super!
I'm super!
I'm super!
Hello
Goodbye

但是，如果我从 Super 类的声明中删除 virtual 关键字：

class Super{
public:
    /*virtual*/ void showName();
};

输出将变得正确一：

I'm super!
I'm special1
I'm special2
Hello
Goodbye

那么，我的问题是，为什么virtual关键字的存在使得指针o1和o2运行方法Super： :showName() 而不是Special1::showName() 还是 Special2::showName()？

Answer 1

使用 virtual 时，输出更接近正确，而使用它时则不正确（除非您确实想要）。强制转换不会更改对象的类型，只会更改指针的类型。它们仍然是 Super 类型，因此应该运行 Super::showName。

将一种指针类型转换为另一种指针类型不会更改所指向事物的类型。怎么可能呢？虚函数的全部要点是能够调用“通用”指针上的方法并获取正确的派生类方法。

为什么使用虚拟函数的典型例子是针对音乐家的。您可能有一个函数，通过在传递的每个 Musician * 上调用 Play 方法，使整个管弦乐队演奏。对于 Pianist 来说，必须调用 Pianist::Play。

通常，编译器会在编译时确定要调用哪个函数——早期绑定。编译器确定知道的唯一信息是指针的类型。 virtual 关键字导致绑定在运行时后期发生，此时类成员的实际类型已知。

顺便说一句，您仍然可以通过使用范围覆盖来调用基类方法。例如o1->Super::showName();。

事实上，你声称“正确”的结果是灾难性的。运行 Special1::showName() 时，this 指针指向非 Special1 类型（或派生自该类型）的对象：未定义的行为很容易导致崩溃。

Answer 2

因为你的 main 中的代码是错误的。这些对象都说“我是超级”，因为对于它们来说（实际上，在后台），最派生的类型仍然是超级。这就是它们被创造出来的样子。

您的静态强制转换打破了所有规则，成为未定义的行为（任何事情都可能发生），因为您告诉编译器 o1 是 Special1，而事实上，它是 < em>不是Special1的类型。

当您创建一堆派生对象并将它们存储在保存指向基对象的指针的指针/容器中时，虚拟函数通常很有用。反之则不然。您想要创建 Special1 和 Special2 类型的指针，并将它们存储在指向 super 的指针中。

Answer 3

在这两种情况下，您的强制转换 (Special1 *o1=static_cast(oSpec);) 都是未定义的行为，因此就语言而言，任何输出都是可以接受的。您获取了一个 Super 类型的对象并对编译器撒谎，告诉它它实际上是一个派生类。在这种情况下，您仍然会得到父类 Super 的实际结果。

Answer 4

您的代码只是未定义。
试图解释它为什么以某种特定的方式工作是没有用的。

这里：

Super *oSpec=new Super;

oSpec 指向 Super 类型的对象。

因此在这些陈述中。强制转换具有未定义的行为，因为 oSpec 指向的对象既不是 Special 1 也不是 Special 2)。

Special1 *o1=static_cast<Special1 *>(oSpec);
Special2 *o2=static_cast<Special2 *>(oSpec);

如果您使用dynamica_cast<> （就像你在创建类层次结构时应该做的那样）。你会发现结果是NULL。

Special1 *o1=dynamic_cast<Special1 *>(oSpec);
Special2 *o2=dynamic_cast<Special2 *>(oSpec);

std::cout << "O1(" << (void*)o1 << ") O2(" << (void*)o2 << ")\n";

这将表明两个指针都是 NULL。