How to « reverse » inheritance when working with polymorphism? - c++

Question

I have a working design in C++, just like the following :
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 ;
};
Now, I'd like to both create a class B which inherit class A with a new void do_other_thing() method and a struct F which inherit struct E with a new int some_other ; attribute.
The method void do_other_thing() could be for example :
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 ;
}
I'm very confused about how to achieve this inheritance.
Especially when it comes to achieve this kind of use case :
// A a ;
a.tick() ;
a.do_something() ;
And :
// B b ;
b.tick()
b.do_something() ;
b.tick() ;
b.do_other_thing() ;
Here comes the question :
Is this even possible ?
If yes, how ?
If not, how to solve the problem with a better stucture ?
EDIT:
As answered, the simplest inheritance pattern will be:
class B : public A {
void do_other_thing(){ // Something }
}
struct F : public E {
int some_other;
}
The problem encountered is that past and futur here are E pointers:
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

You could 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 ;
}
or you could use a second pair of pointer members in B which point to the same objects as futur and past (more data, less casting - essentially caching the runtime cast)
or you could use a template base class where the type of past and futur is a template parameter (sometimes requires the introduction of a non-templated "root class" and making everything virtual).
And probably quite a few other ways, with varying trade-offs, benefits, and complications.
What to choose depends on the rest of your program and your personal preferences.

Answer 2

First, yes it is possible. The following is just pseudo-code for illustration:
class B : public A {
void do_other_thing(){ std::cout << "Other" << std::endl; }
}
struct F : public E {
int some_other;
}
Now both of these new types will follow the principle of being able to take the place of their parent types. This is achieved by referring to the sub-types by a pointer to their base types (polymorphism).
std::shared_ptr<A> baseARefToB{ std::make_shared<B>() };
baseRefToB->do_something();
std::shared_ptr<E> baseERefToF{ std::make_shared<F>() };
baseERefToF->some_properties = 3;
Note that I cannot access their sub-class methods and properties via the base class references. BUT:
std::static_pointer_cast<B>(baseRefToB)->do_other_thing();
std::static_pointer_cast<E>(baseERefToF)->some_other = 42;
Here I have cast the references to their base types so I can access their sub-class specific functionality.
So from your problem description you will be able (always) to call the base class functionality (do_something and some_properties) for all types of A and E, but you will only be able to access the sub-class functionality if you refer to the object via pointers with the correct type.