Modèle de conception pour les fonctions optionnelles?

Question

J'ai une classe de base qui sous-classes dérivées héritent, il porte les fonctions de base qui devraient être les mêmes dans toutes les classes dérivées:

class Basic { 
public: 
    Run() { 
     int input = something->getsomething(); 
     switch(input) 
     { 
      /* Basic functionality */ 
      case 1: 
       doA(); 
       break; 
      case 2: 
       doB(); 
       break; 
      case 5: 
       Foo(); 
       break; 
     } 
    } 
}; 

Maintenant, en fonction de la classe dérivée, je veux « ajouter » plus déclarations de cas au commutateur. Quelles sont mes options ici? Je peux déclarer des fonctions virtuelles et ne les définir dans les classes dérivées qui vont les utiliser:

class Basic { 
protected: 
    virtual void DoSomethingElse(); 
public: 
    Run() { 
     int input = something->getsomething(); 
     switch(input) 
     { 
      /* Basic functionality */ 
      ... 

      case 6: 
       DoSomethingElse(); 
     } 
    } 
}; 


class Derived : public Basic { 
protected: 
    void DoSomethingElse() { ... } 
} 

Mais cela signifierait lors du changement des fonctions dans une classe dérivée, je dois modifier ma classe de base pour refléter les changements.

Existe-t-il un modèle de conception spécifique à ce type de problème? J'ai acheté un certain nombre de livres sur Design Patterns, mais je les étudie sur la base des besoins, donc je ne sais pas s'il y a un tel modèle que je cherche.

Answer 1

Vous pouvez trouver utile de lire environ Chain of responsibility pattern et de repenser votre solution de cette façon.

Vous pouvez également déclarer 'doRun' comme méthode protégée et l'appeler dans le cas par défaut de la base.

default: 
    doRun(input); 

Et de définir doRun dans les classes dérivées.

Il en est ainsi appelé Template Method pattern

Answer 2

La procédure normale consiste à utiliser une usine. En résumé:

• créer une hiérarchie de classes connexes qui fournissent la fonctionnalité.
• créer une classe d'usine qui prend l'entrée et crée une instance du droit kindf de classe en fonction de l'entrée

Maintenant, pour les points bonus ajoutés:

• créer un système qui reghisters cours withn l'usine - vous aurez besoin de spécifier l'entrée et le type de la classe à traiter

Maintenant, quand un besoin d'une nouvelle entrée vient, vous venez de dériver une nouvelle classe et l'enregistrer avec le usine. Le besoin de l'instruction switch disparaît.

Answer 3

Je pense que le modèle dont vous avez besoin est chaîne de responsabilité ou peut-être stratégie combinée à une table d'appel dynamique ...

Answer 4

Mais cela signifierait lors du changement fonctions dans une classe dérivée, je devrait éditer ma classe de base à refléter ces changements.

Pourquoi cela serait-il vrai?

Je tiens compte de votre commentaire - alors si vous choisissez cette approche, vous aurez ces problèmes. D'autres ont posté des réponses qui suggèrent d'autres solutions - je vérifierais pour voir si elles vous aident.

Answer 5

Si vos valeurs de sélection ne sont que de petits entiers, je remplacerais la déclaration de cas par une table de consultation. (Les actions dans le cas devront chacune être codées comme une fonction, ainsi vous pouvez mettre des pointeurs de fonction dans la table). Les classes héritées peuvent simplement ajouter des entrées à la table. (Je suppose que la table doit être une propriété d'instance, elle ne peut pas être statique).

Colin

Answer 6

solution simple А:

class Basic { 
    public: 
    void Run() { 
     const int input = ... 
     if (!(BaseProcess(input) || Process(input))) ... 
    } 

    vitual bool Process(int input) { return false; } 

    bool BaseProcess(int input) { 
     switch(input) { 
    ... 
     default: return false; 
     } 
     return true; 
    } 
... 

... et puis mettre en œuvre des cas supplémentaires dans la sous-classe Process(). Si vous devez prendre en charge plus de 2 niveaux (sous-sous-classe en ajoutant encore plus de cas), vous avez besoin d'une table de répartition dynamique.