Discussion :

[sfarc]

Bonjour,

J'ai l'architecture suivante :

- classe ModelB et ModelC héritent d'une classe mère Model.
- classe ControlerB et ControlerC héritent d'une class mère Controler.
- classe ControlerB est composée d'un objet ModelB qu'elle contrôle.
- classe ControlerC est composée d'un objet ModelC qu'elle contrôle.

Est-il préfèrable de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
class Controler {
  public :  
    Controler();  
    ~Controler();  
    void SetModel(Model*);  
 
 protected :  
   Model* model;  
}

et caster le model dés que nécessaire dans les classes filles ou faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Controler {
  public :  
    Controler();  
    ~Controler();  
}
 
class ControlerB {
  public :  
    //...
    void SetModel(ModelB*);
 
  private :
    ModelB* _model; 
}
 
class ControlerC {
  public :  
    //...
    void SetModel(ModelC*);
 
  private :
    ModelC* _model; 
}

et ne pas exploiter le polymorphisme ?

Pour information, les modèles ModelB et ModelC sont très éloignés (Model représente un haut degrés d'abstraction) et partagent donc très peu de méthodes communes (d'ou ma question car un ControlerB ne serait par exemple pas adapté pour gérer un ModelC d'un point de vue purement logique de conception... (d'un point de vue technique, les casts permettent de résoudre ce problème)).

Merci

[ternel]

essaye de templater la classe Controleur.
éventuellement, rend Controleur abstraite

[sfarc]

Merci leternel de ton aide

éventuellement, rend Controleur abstraite

Oui je peux même définir une interface pour le Controler.

essaye de templater la classe Controleur.

Mais justement, est-il judicieux de rendre générique le Controler alors que les Controlers spécifiques auront des modèles très différents (voire trop justement) pour que la logique de factorisation n'ait pas de sens ici ?

[ternel]

Certainement, vu que tu as une interface de base.
Qu'ils héritent de la même classe signifie qu'ils partagent la sémantique de cette classe.

Cela se partage sûrement.

[sfarc]

Tu me conseilles donc de faire par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<class T>
class Controler
{
 
};
 
class ControlerB : public Controler<ModelB>
{
 
};
 
class ControlerB : public Controler<ModelC>
{
 
};

pour éviter les casts à répétition sur un Controler qui de base aurait en membre un type abstrait Model ?
Après, comme les modèles sont utilisés pour deux choses très différentes, la notion de template ne sera pas beaucoup plus exploitable je pense .

Je débute en template donc j'essaie de voir ce que ça peut m'apporter en plus dans mon cas!

[koala01]

Salut,

A priori, si tu décide de faire hériter différents modèles d'une classe de base, c'est que tu as sans doute une interface minimum commune.

Si tu choisi de placer le modèle ("de base") dans la classe de base "controler", tu ne pourras profiter utiliser ton modèle au travers de ton contrôleur que... sous la forme sous laquelle le contrôleur le connais, à savoir : le modèle "de base".

Maintenant, rien ne t'empêche de prévoir une fonction virtuelle (pure, dans le modèle de base) qui prenne un "indice" en argument et qui renvoie, d'une manière ou d'une autre, la valeur correspondant à cet indice. Tu pourrais donc, pour chaque modèle particulier, redéfinir cette fonction de manière à ce qu'elle fournisse une valeur "cohérente".

Pour pouvoir travailler "facilement", la valeur renvoyée serait sans doute du genre de boost::any ou boost::variant

Une autre solution pourrait consister à utiliser ce que l'on appelle le "retour co-variant".

L'idée étant, dans la classe de base de contrôleur, de déclarer une fonction virtuelle pure renvoyant un pointeur sur le modèle de base, et de la redéfinir, dans les classes dérivées, de sorte à ce qu'elle renvoie un pointeur sur le modèle spécifique géré par ton contrôleur.

Tu peux alors envisager les deux solutions : le fait de maintenir ce pointeur au niveau de la classe de base contrôleur, en redéfinissant la fonction sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
ModeleDerive * ControleurDerive::model(){return dynamic_cast<ModeleDerive>(Controler::model());}

tout comme tu pourrais tout aussi bien considérer que le modèle spécifique est une information qui ne doit pas être maintenue au niveau de la classe de base des contrôleurs, mais qui doit être maintenue au niveau de leurs classes dérivées.

Il n'y a, à ce niveau, ni "bonne" ni "mauvaise" décision, dans le sens où elles seraient toutes les deux parfaitement cohérentes.

Cependant, on dit souvent qu'un interface ne devrait disposer que des données strictement minimales pour fournir les comportements "immuables" (ceux qui n'ont en aucun cas vocation à être redéfinis ).

Or, tous les comportements ayant trait à la gestion du modèle a, j'ai envide de dire forcément, vocation à être redéfinis.

Il serait donc sans doute "de bon ton" de faire en sorte que le modèle particulier géré par un contrôleur particulier ne soit contenu que dans ce contrôleur particulier (mais ce n'est qu'un avis strictement personnel).

Par contre, je ne crois sincèrement pas qu'il soit opportun de fournir un mutateur "setModel":

D'abord, parce que le prototype de ce mutateur serait "figé" et prendrait d'office un Model * au lieu d'un ModelParticulier *

Ensuite parce que l'idéal est à mon sens d'avoir un contrôleur directement utilisable dés la construction: une fois que tu as créé une instance de contrôleur, tu ne devrais avoir rien d'autre à faire pour pouvoir l'utiliser.

De plus, il y a de fortes chances pour que, si tu veux travailler avec un autre modèle, il faille... travailler avec un autre contrôleur.

Tout cela pour dire que, à mon sens, tu devrais sans doute t'orienter vers quelque chose qui serait proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Controler
{
    /* les fonctions virtuelles pures "qui vont bien" */
}
class ControlerB : public Controler
{
    public:
        ControlerB(ModelB* model):model_(model){}
        /* redéfinition des fonction qui vont bien */
    private:
        ModelB * model_;
};

NOTA: si tu prend cette direction, tu pourrais d'ailleurs tout à fait travailler avec des références (éventuellement constantes) plutôt qu'avec des pointeurs, ce qui devrait encore te faciliter la tâche