在 C++ 中类继承的情况下强制延迟方法解析

考虑以下类结构：-

    class foo {
    public:
      int fun () {
        cout << "in foo" << endl;
      }
    };

    class bar_class1:public foo {
    public:
      int fun () {
        cout << "in bar_class1" << endl;
      }
    };

    class bar_class2:public foo {
    public:
      float fun () {
        cout << "in bar_class2" << endl;
      }
    };

    main () {
      foo * foo_pointer = new bar_class1();
      foo_pointer->fun();
    }

上述程序的输出是in foo。有没有办法使用类型指针foo *它实际上指向一个类型的对象bar_class1 or bar_class2，我们可以调用fun派生类的函数而不是基类的函数？我无法做到fun基类中的虚函数foo既然，那么函数存在返回类型冲突foo在派生类中bar_class2.

这是我的评论作为答案。

你不能这样做。

如果这种多态性是可能的，那么当代码调用时不会严重破坏吗foo::fun（期望一个 int）在一个实际类型为 bar_class2 的对象上并因此得到一个 float？您想简单地丢弃类型安全吗？

如果您想要不同的返回类型，听起来您需要一个模板。但是您不能像使用 foo() 那样使用模板。静态多态性（模板）和运行时多态性（后期绑定）不能很好地混合。您需要重新设计您的 oop 结构。

如果你绝对讨厌类型安全，你可以sort of使用 void 指针执行此操作。但是出于对 Flying Spaghetti Monster 的热爱，永远不要在 C++ 中这样做。请在阅读以下代码前闭上眼睛，避免接触。

#include <iostream>

class foo {
public:
    virtual void* fun() = 0;
    virtual ~foo(){};
};

class bar_class1: public foo {
public:
    void* fun() {
        return &value;
    }
private:
    int value = 1;
};

class bar_class2: public foo {
public:
    void* fun() {
        return &value;
    }
private:
    float value = 1.1;
};

int main() {
    foo* foo_pointer1 = new bar_class1();
    foo* foo_pointer2 = new bar_class2();

    // in c++ compiler must know the type of all objects during compilation
    std::cout << *reinterpret_cast<int*>(foo_pointer1->fun()) << '\n';
    std::cout << *reinterpret_cast<float*>(foo_pointer2->fun()) << '\n';
    delete foo_pointer1;
    delete foo_pointer2;
}