Come faccio a creare un modulo * per una classe che si basa su un altro modulo?

0

* 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.

    
posta Carcigenicate 13.05.2015 - 16:19
fonte

1 risposta

1

Alcune alternative:

  1. Avere RandomWalk ereditato da posizionale. Con questa definizione, un RandomWalk è un'entità posizionale che può camminare casualmente o in posizioni specifiche. Non mi piace molto questo approccio; non lascia alcun modo di gestire i permutatori arbitrari delle permutazioni (ad es. RandomWalk, SquareDanceWalk, ecc.).

  2. Avere RandomWalk contiene una funzione "WalkRandomly" che accetta un parametro posizionale. Le entità che necessitano di un movimento casuale possono chiamare questa funzione. Se necessario, è possibile ereditare una classe astratta ICanRandomWalk (l'ereditarietà del diamante va bene se non più di una classe base contiene un'implementazione), con ICanRandomWalk implementato come chiamata di un membro di un'istanza privata di RandomWalk.

risposta data 13.05.2015 - 20:34
fonte

Leggi altre domande sui tag