* Sto usando "Modulo" per indicare alcune estensioni di una classe, sia per ereditarietà che per composizione.
Supponiamo di avere una delle seguenti dichiarazioni di Entity
:
using EUnit = int;
class Entity : /*With inheritance*/
Positional<EUnit> {
public:
Entity();
};
o
class Entity { /*With composition*/
Position<EUnit> pos; //Same as "Positional", but renamed
public:
Entity();
};
E la dichiarazione di Position
/ Positional
:
template <class T>
class Positional {
T xPos;
T yPos;
public:
Positional();
Positional(T x, T y);
void moveTo(T x, T y);
void moveBy(T xOff, T yOff);
T getX() const;
T getY() const;
};
Che cosa succede se voglio creare una classe chiamata RandomWalk
che può essere utilizzata per causare il Entity
(o qualsiasi altra classe Positional
) per spostarsi casualmente in una posizione?
Seguendo il percorso di ereditarietà, ho pensato di ereditare RandomWalk
da Positional
in modo che abbia accesso a una posizione su cui agire. Se poi ho impostato Entity
come:
class Entity :
Positional<EUnit>, virtual RandomWalk<EUnit> { ...
RandomWalk
ora come l'accesso alla posizione di Entity
, ma ha coinvolto "l'ereditarietà del diamante". Sto praticamente ereditando RandomWalk
, quindi dovrebbe esistere solo una versione di Positional
, ma l'ereditarietà multipla come questa sembra ancora disapprovata da ciò che ho letto.
Questo mi lascia con la composizione. L'unico modo in cui potevo pensare di dare a RandomWalk
l'accesso alla posizione di Entity
in questo modo era di fare qualcosa come passare un riferimento / puntatore al Entity
Positional
al costruttore RandomWalk
. Usare i puntatori per qualcosa di simile sembra comunque eccessivo.
E ora sono fuori di idee e mi piacerebbe suggerimenti / consigli (o solo commenti generali sul problema).
So che potrei aggiungere direttamente una funzione randomWalk
a Entity
, ma la sto osservando nella prospettiva del riutilizzo.
E sì, RandomWalk
è una specie di stupido caso d'uso, ma sono sicuro che questo problema (o uno simile) si verifica nel mondo reale.