Interfacce leggermente diverse

Question

Interfacce leggermente diverse

#1 da (3 voti)
#2 da (2 voti)

0

Sto creando una classe che ha una variabile di istanza con diverse implementazioni, ma il problema è che tutte le implementazioni hanno un'interfaccia leggermente diversa.

Esempio:

class GameObject {
    virtual Transform * getTransform() = 0;
};

class Transform {
    virtual void setPosition() = 0;
    virtual Model getModel() = 0;
    virtual void refreshModel() = 0;
    virtual void Draw() = 0;
};

// This Class has a .cpp
class TransformImpl : public Transform {
    virtual void setPosition();
    Model getModel();
    void refreshModel();
    void Draw();
};

// This Class has a .cpp
class InstancedTransformImpl : public Transform {
    void setPosition(int instance);
    std::vector<Model> getModels(); // notice the difference in the interface
    void refreshModel();
    void Draw();
};

Il punto che voglio fare è che voglio solo una classe GameObject quindi voglio che il mio metodo geTransform() abbia un tipo di ritorno di classe Transform . Il problema che sto avendo è che poiché TransformImpl e InstancedTrasformImpl hanno interfacce leggermente diverse non posso avere getTransform() per restituire un Transform e invece ho bisogno di implementare GameObject due volte con un sacco di codice duplicato.

C'è una buona soluzione per implementare GameObject una volta?

O sarebbe meglio avere più implementazioni GameObject ciascuna avente rispettivi Transform di Impl con un'interfaccia più clemente?

c++ design-patterns object-oriented-design

posta Archmede 25.07.2017 - 00:15

fonte

2 risposte

2

E il modello dell'adattatore?
Crea diversi tipi di implementazioni di GameObject e lavora con tutti attraverso un adattatore che ne astragga le differenze: link

risposta data 25.07.2017 - 07:19

fonte

Leggi altre domande sui tag c++ design-patterns object-oriented-design

In Qt o C ++, c'è un buon mezzo per creare uno switch con casi generati dinamicamente, o dovrei semplicemente usare un ciclo for (o qualcos'altro)? Garantire la mancanza di dati nella serializzazione

score 3 · Accepted Answer

Se si desidera utilizzare due (o più) classi di implementazione in modo intercambiabile, allora tali classi di implementazione devono implementare la stessa interfaccia. Questo è particolarmente importante se la selezione della classe di implementazione con cui si interagisce viene decisa in fase di runtime.

Se la differenza tra le interfacce è che una classe consente l'accesso a N istanze di qualcosa e l'altra a solo 1, l'interfaccia comune dovrebbe consentire l'accesso a N istanze.
L'accesso a un numero più ristretto può essere modellato come caso speciale della situazione con accesso a un numero illimitato.

In questo caso, l'interfaccia dovrebbe essere

class Transform {
    virtual void setPosition(int instance) = 0;
    virtual std::vector<Model> getModel() = 0;
    virtual void refreshModel() = 0;
    virtual void Draw() = 0;
};

La classe TransformImpl può quindi sempre restituire un vettore con 1 elemento da getModel e ignorare il parametro instance su setPosition o segnalare un errore se tale parametro ha un valore diverso da 0 o 1 (a seconda su dove inizi a contare).