Déclaration de commutation géante pour les constructeurs

Question

J'ai un conteneur qui contient un tas de pointeurs vers une classe de base, et une fonction qui prend une entrée et renvoie une classe qui est une sous-classe de la classe de base. La sous-classe qu'elle renvoie dépend de l'entrée.

En ce moment, j'ai une déclaration d'interrupteur géant comme ça :

class Base { ... }

class A : public Base { ... }
class B : public Base { ... }
...
class Z : public Base { ... }

Base* depends(int input) {
    switch (input) {
    case 1:
        return new A(...);
    case 2:
        return new B(...);
    ...
    case 26:
        return new Z(...);
    default:
        ...
    }
}

Je me demandais s'il y avait une meilleure façon de concevoir cela. Je ne connais pas beaucoup de "modèles de conception" (je crois que c'est ainsi qu'ils s'appellent) et je ne sais donc pas s'il existe une meilleure façon (évidente) de concevoir ce projet.

Answer 1

Ce que vous recherchez, c'est un Modèle de méthode d'usine .

L'important ici est de supprimer la nécessité pour la classe de base d'avoir une connaissance des implémentations des classes dérivées. C'est une mauvaise conception pour une classe de base d'avoir des connaissances sur les classes dérivées.

Le modèle Factory Method résout le problème ci-dessus car la création a lieu en dehors de la classe de base.

Answer 2

Il est un peu difficile de comprendre ce que vous voulez faire, mais vous pourriez envisager d'utiliser le modèle Abstract Factory si vous voulez créer un grand nombre de sous-classes différentes en fonction d'un paramètre d'entrée.

Answer 3

Une autre solution consiste à créer un tableau dans lequel vous placerez des pointeurs vers les fonctions qui appelleront le constructeur correspondant. Et dans votre depends() vous n'appellerez que la fonction dont vous avez besoin par l'entrée donnée. Mais de toute façon, vous avez besoin de 26 fonctions dans cette approche.

Answer 4

Le paramètre entier "input" vient de quelque part. Vous pouvez peut-être laisser le code qui a créé cet int créer l'objet réel à la place. Cela ne fonctionnera pas si vous lisez l'entier depuis le disque ou quelque chose comme ça.

Vous pourriez envisager de mettre en place une situation où les différentes sous-classes s'enregistrent elles-mêmes auprès de l'objet qui les crée. Dans ce cas, l'objet usine n'aurait pas besoin de connaître les sous-classes au moment de la compilation. Vous pouvez le faire au moment du démarrage en utilisant des variables globales dont les constructeurs font l'enregistrement pour chaque sous-classe. Votre instruction switch est plus simple et plus rapide, mais cela signifie que vous devez maintenir le switch à jour lorsque vous changez les sous-classes. C'est un compromis et je ne pense pas que votre solution soit nécessairement inférieure à une solution plus élaborée.