Diamant héritage (C++)

Je sais que le fait d'avoir de diamant de l'héritage est considéré comme une mauvaise pratique. Cependant, j'ai 2 cas dans lequel je me sens le diamant héritage conviendrait très bien. Je veux demander, voulez-vous me recommander d'utiliser le diamant de l'héritage dans ces cas, ou est-il une autre conception qui pourrait être mieux.

Cas 1: je veux créer des classes qui représentent les différents types de "Mesures" dans mon système. Les actions sont classées par plusieurs paramètres:

  • L'action peut être "Lu" ou "Écrire".
  • L'action peut être avec retard ou sans retard (Il n'est pas juste 1 paramètre. Il modifie le comportement de façon significative).
  • L'action du "flux de type" peut être FlowA ou FlowB.

J'ai l'intention d'avoir la structure suivante:

//abstract classes
class Action  
{
    //methods relevant for all actions
};
class ActionRead      : public virtual Action  
{
    //methods related to reading
};
class ActionWrite     : public virtual Action  
{
    //methods related to writing
};
class ActionWithDelay : public virtual Action  
{
    //methods related to delay definition and handling
};
class ActionNoDelay   : public virtual Action  {/*...*/};
class ActionFlowA     : public virtual Action  {/*...*/};
class ActionFlowB     : public virtual Action  {/*...*/};

//concrete classes
class ActionFlowAReadWithDelay  : public ActionFlowA, public ActionRead, public ActionWithDelay  
{
    //implementation of the full flow of a read command with delay that does Flow A.
};
class ActionFlowBReadWithDelay  : public ActionFlowB, public ActionRead, public ActionWithDelay  {/*...*/};
//...

Bien sûr, j'obéirai qu'aucun des 2 actions (héritant de la classe d'Action) mettra en œuvre la même méthode.

Cas 2: j'implémente le design pattern composite pour une "Commande" dans mon système. Une commande peut être lu, écrit, supprimés, etc. Je veux aussi avoir une séquence de commandes, qui peut aussi être lu, écrit, supprimés, etc. Une séquence de commandes peuvent contenir d'autres séquences de commandes.

J'ai donc le dessin suivant:

class CommandAbstraction
{
    CommandAbstraction(){};
    ~CommandAbstraction()=0;
    void Read()=0;
    void Write()=0;
    void Restore()=0;
    bool IsWritten() {/*implemented*/};
    //and other implemented functions
};

class OneCommand : public virtual CommandAbstraction
{
    //implement Read, Write, Restore
};

class CompositeCommand : public virtual CommandAbstraction
{
    //implement Read, Write, Restore
};

En plus, j'ai un type spécial de commandes, "Moderne" des commandes. À la fois une commande et composite de commande peut être moderne. Être "Moderne", ajoute un certain nombre de propriétés d'une commande et composite de commande (essentiellement les mêmes propriétés pour les deux). Je veux être capable de tenir un pointeur vers CommandAbstraction, et l'initialiser (par le biais des nouvelles) selon le type de commande. Donc, je veux faire de la conception suivantes (en plus de ci-dessus) :

class ModernCommand : public virtual CommandAbstraction
{
    ~ModernCommand()=0;
    void SetModernPropertyA(){/*...*/}
    void ExecModernSomething(){/*...*/}
    void ModernSomethingElse()=0;

};
class OneModernCommand : public OneCommand, public ModernCommand
{
    void ModernSomethingElse() {/*...*/};
    //... few methods specific for OneModernCommand
};
class CompositeModernCommand : public CompositeCommand, public ModernCommand
{
    void ModernSomethingElse() {/*...*/};
    //... few methods specific for CompositeModernCommand
};

Encore une fois, je ferai en sorte qu'aucun des 2 classes héritant de CommandAbstraction classe mettra en œuvre la même méthode.

Merci.

InformationsquelleAutor Igor Oks | 2008-12-18