Discussion :

[bouba]

Bonjour, je cherche une solution pour résoudre un problème dans une bibliothèque C++ que je suis en train de concevoir. J'ai cherché du côté des Design Patterns et de la méta-programmation (Policies, traits, etc..), mais étant débutant je vais avoir besoin d'un aide extérieure.

Voici ce que je souhaite pouvoir réaliser,
j'ai une classe

Code :

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

1
2
3
4
5
6
 
class Classifieur {
...
virtual void classifier(Base & base) throw(ExceptionFormatBase) = 0;
...
};

Dans ma librairie un classifieur peut avoir 3 comportements différents: RANG, CLASSE, MESURE (c'est ce que je n'arrive pas à modéliser). Un classifieur permet de classifier les éléments d'une Base. Dans le cas du comportement CLASSE le classifieur doit disposer d'une fonction classifier comme celle qui est au dessus. Dans les deux autres cas la fonction classifieur doit être différente et retourner un tableau de tableaux.

Par exemple générer un code comme celui-ci:

Code :

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

1
2
3
4
5
6
 
class Classifieur {
...
virtual vector<vector<double>*>* classifier(Base & base) throw(ExceptionFormatBase) = 0;
...
};

Aussi, j'ai de multiples classes dérivées de Classifieur, elle doivent hériter de cette fonction suivant le type RANG, CLASSE ou MESURE.

Bref, ce que je veux faire c'est pouvoir générer une fonction différente suivant les cas RANG, CLASSE et MESURE. Mais la classe doit évidemment rester un Classifieur, est-il possible de faire ceci à l'aide des templates ? Comment résoudre ce problème ?

Merci pour votre aide.

Bouba

[IrmatDen]

Salut,

As-tu regardé du côté du DP Stratégie?
J'ai l'impression que c'est ce qu'il te faut, si tu fais abstraction du nom de la méthode exposée par Classifier (on peux imaginer le nom exposé comme "use()" ou quelque chose du style). Bien sûr, c'est pas à base de template comme solution, mais la description de ton problème ressemble à la définition de ce DP

Aussi, j'ai de multiples classes dérivées de Classifieur, elle doivent hériter de cette fonction suivant le type RANG, CLASSE ou MESURE.

C'est à dire?

[bouba]

C'est à dire?

Toutes mes classes dérivées seront soit de type RANG, CLASSE ou MESURE. Si j'ai:

Code :

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

1
2
3
4
5
 
class Classifieur {};
 
class ClassifieurSpecifique : public Classifieur {
}

Si la classe Classifieur est de type RANG la fonction classifier doit avoir cette forme

Code :

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

1
2
3
4
5
6
7
8
 
class Classifieur {
virtual void classifier(Base & base) throw(ExceptionFormatBase) = 0;
};
 
class ClassifieurSpecifique : public Classifieur {
virtual void classifier(Base & base) throw(ExceptionFormatBase);
};

Si la classe Classifieur est de type MESURE je dois avoir ceci.

Code :

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

1
2
3
4
5
6
7
8
 
class Classifieur {
virtual vector<vector<double>*>* classifier(Base & base) throw(ExceptionFormatBase) = 0;
};
 
class ClassifieurSpecifique : public Classifieur {
virtual vector<vector<double>*>* classifier(Base & base) throw(ExceptionFormatBase);
};

Je regarde tout de suite le DP Strategy, merci.

[bouba]

En fait, ce que je veux faire c'est un peu comme le DP Strategy mais la différence est que je veux en plus générer une interface différente de la fonction classifier() en fonction du type (RANG, MESURE, CLASSE) de la classe Classifieur. C'est peut-être faisable avec des stratégies basées sur les templates ?

[IrmatDen]

Ah, ok, ça correspond pas si bien que ça alors, désolé de l'incompréhension

Ca marcherait avec une petite abstraction du type de retour, mais je ne suis pas certain que ce soit la solution la plus adaptée... Pour expliciter, tu aurais:
> classe Classifieur
> classe ClassifieurComportement abstraite qui sert de base aux autres
> une classe ClassifieurComportementRetour qui sert de base abstraite aux types de retour de chaque comportement (dans lesquelles il peut tout simplement n'y avoir qu'un membre public; ça permet simplement d'avoir une signature standard pour le retour de l'appel au ClassifieurComportement en cours d'utilisation)
L'inconvénient étant que ça peut t'obliger à passer par des dynamic_cast<> pour les valeurs de retour

Ceci dit, une solution à base de template est peut-être plus indiqué, mais je ne vois pas comment :/

[bouba]

OK, merci beaucoup.

[Mat007]

Salut,

Ca nécessiterait sans doute de repenser une partie de l'algorithme (et de revoir l'approche générale aussi) mais à tout hasard voici comment je règlerais le problème : plutôt que de demander à un Classifieur de transformer des données je lui demanderais de réaliser un traitement.
En pratique je configurerais Classifieur avec un observateur qui pourrait ressembler à :

Code :

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

1
2
3
4
5
6
 
class Observer
{
public:
  virtual void notify( vector<vector<double>*>* ) = 0;
};

(au passage un pointeur sur un vecteur c'est bizarre, en const& c'est sans doute mieux)
(j'ai aussi un peu de mal avec les conventions de code en français mais c'est un choix )

Du coup Classifieur::classifier renverrait toujours void et serait uniforme, la différence se passerait au niveau de chaque implémentation qui pourrait décider d'appeler notify ou pas (on peut aussi avoir plusieurs versions de notify).

Donc forcément ça change la manière d'utiliser des Classifieur, mais c'est beaucoup plus souple au final.

MAT.