c++ - 使用多态性时如何“反转”继承？

Question

我有一个 C++ 的工作设计，如下所示:

struct E {
    int some_properties ;
    // … some more
};

class A {
    public:
        void tick() {
            std::swap(futur, past) ;
        }

        void do_something() {
            // do something (read past, write futur)
            futur->some_properties = past->some_properties + 1 ;
        }

        E* past ;
   protected:
        E* futur ;
};    

现在，我想同时创建一个 class B，它继承了 class A 和一个新的 void do_other_thing() 方法和一个struct F 继承了 struct E 和一个新的 int some_other ; 属性。

void do_other_thing() 方法可以是例如:

void do_other_thing() {
    // do something (read past, write futur)
    futur->some_properties = past->some_properties + past->some_other ;
    futur->some_other = past->some_other + 1 ;
}

我很困惑如何实现这种继承。

特别是在实现这种用例时:

// A a ;
a.tick() ;
a.do_something() ;

和:

// B b ;
b.tick()
b.do_something() ;
b.tick() ;
b.do_other_thing() ;

问题来了:

• 这可能吗？

• 如果是，怎么做？

• 如果不是，如何用更好的结构解决问题？

编辑:

正如回答的那样，最简单的继承模式是:

class B : public A {
    void do_other_thing(){ // Something }
}

struct F : public E {
    int some_other;
}

遇到的问题是这里的past和futur是E指针:

void do_other_thing() {
    // do something (read past, write futur)
    futur->some_properties = past->some_properties + past->some_other ;
    futur->some_other = past->some_other + 1 ;
}

Answer 1

你可以dynamic_cast:

void do_other_thing() {
    F* futur_f = dynamic_cast<F*>(futur);
    F* past_f = dynamic_cast<F*>(past);
    assert(futur_f && past_f);
    futur_f->some_properties = past_f->some_properties + past_f->some_other ;
    futur_f->some_other = past_f->some_other + 1 ;
}

或者您可以在 B 中使用第二对指针成员，它们指向与 futur 和 past 相同的对象(更多数据，更少的转换——本质上是缓存运行时转换)

或者您可以使用模板基类，其中 past 和 futur 的类型是模板参数(有时需要引入非模板化的“根类”并使一切虚拟化)。

可能还有很多其他方式，具有不同的权衡、好处和复杂性。

选择什么取决于您程序的其余部分和您的个人喜好。