Bonjour,
Ne connaissant pas l'existence des unary_function de la stl j'avais
spontanément adopté un design consistant à différencier les prédicats
en fonction de leur domaine d'application en les faisant hériter d'une
classe abstraite représentant le domaine d'application.
exemple :
// abstract class
class PredicateGrooveDefiner {
//! recherche si une cellule est dans un sillon
virtual bool operator()(Cell const&)=0;
}
// later derived in
// a cell is considered as a putative groove if it has a requested
size
PredicateGrooveDefinerVolume:public PredicateGrooveDefiner;
// a cell is considered as a putative groove if it's vertices have a
good curvature index
PredicateGrooveDefinerVerticesCurvature:public PredicateGrooveDefiner;
Je me demandais dans quelle mesure c'est une bonne idée / bonne
pratique. Et maintenant, je me demande s'il ne serait pas possible (et
bon usage) d'hériter en plus de unary_function<Cell,boo>.
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Bonjour,
Ne connaissant pas l'existence des unary_function de la stl j'avais
spontanément adopté un design consistant à différencier les prédicats
en fonction de leur domaine d'application en les faisant hériter d'une
classe abstraite représentant le domaine d'application.
exemple :
// abstract class
class PredicateGrooveDefiner {
//! recherche si une cellule est dans un sillon
virtual bool operator()(Cell const&)=0;
}
// later derived in
// a cell is considered as a putative groove if it has a requested
size
PredicateGrooveDefinerVolume:public PredicateGrooveDefiner;
// a cell is considered as a putative groove if it's vertices have a
good curvature index
PredicateGrooveDefinerVerticesCurvature:public PredicateGrooveDefiner;
Je me demandais dans quelle mesure c'est une bonne idée / bonne
pratique. Et maintenant, je me demande s'il ne serait pas possible (et
bon usage) d'hériter en plus de unary_function<Cell,boo>.
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Bonjour,
Ne connaissant pas l'existence des unary_function de la stl j'avais
spontanément adopté un design consistant à différencier les prédicats
en fonction de leur domaine d'application en les faisant hériter d'une
classe abstraite représentant le domaine d'application.
exemple :
// abstract class
class PredicateGrooveDefiner {
//! recherche si une cellule est dans un sillon
virtual bool operator()(Cell const&)=0;
}
// later derived in
// a cell is considered as a putative groove if it has a requested
size
PredicateGrooveDefinerVolume:public PredicateGrooveDefiner;
// a cell is considered as a putative groove if it's vertices have a
good curvature index
PredicateGrooveDefinerVerticesCurvature:public PredicateGrooveDefiner;
Je me demandais dans quelle mesure c'est une bonne idée / bonne
pratique. Et maintenant, je me demande s'il ne serait pas possible (et
bon usage) d'hériter en plus de unary_function<Cell,boo>.
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire cette
séparation. Tu peux aussi passer par les templates où par un autre pattern
(strategy ...). C'est une question de design.
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire cette
séparation. Tu peux aussi passer par les templates où par un autre pattern
(strategy ...). C'est une question de design.
Pour la petite histoire, je pense que j'en suis venu à ce "design" à
partir du souvenir d'une observation (de James Kanze si je me souviens
bien) lue ici même il y a quelques années (déjà O_o) et qui disait en
substance qu'il fallait séparer les problèmes et les implémentations.
Tu dois vouloior dire séparer les interfaces et les implémentations.
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire cette
séparation. Tu peux aussi passer par les templates où par un autre pattern
(strategy ...). C'est une question de design.
A mon avis, james parlait surement du pimpl (même si c'est vrai que c'es t un
peu pareil que le strategy structurellement parlant)...
A mon avis, james parlait surement du pimpl (même si c'est vrai que c'es t un
peu pareil que le strategy structurellement parlant)...
A mon avis, james parlait surement du pimpl (même si c'est vrai que c'es t un
peu pareil que le strategy structurellement parlant)...
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les
prédicats de même signature mais pas de même utilisation. i.e.
tu peux avoir un prédicat qui va te servir à trier les
cellules que tu veux aggréger (première étape de l'algo), et
un autre pour les cellules que tu veux retirer (seconde étape
de l'algo).
Utiliser une classe virtuelle pure n'est pas le seul moyen
de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente
ne saurait être implémentéecette séparation. Tu peux aussi passer par les templates où
par un autre pattern (strategy ...). C'est une question de
design.
Pour être certain de bien te comprendre : pour moi dans le
pattern strategie tu as un objet qui en agrège un autre (la
stratégie, généralement d'un type abstrait (pur ?) d'ailleurs)
et lui délègue le boulot. Comment tu mettrais ça en pratique
dans mon contexte ?
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les
prédicats de même signature mais pas de même utilisation. i.e.
tu peux avoir un prédicat qui va te servir à trier les
cellules que tu veux aggréger (première étape de l'algo), et
un autre pour les cellules que tu veux retirer (seconde étape
de l'algo).
Utiliser une classe virtuelle pure n'est pas le seul moyen
de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente
ne saurait être implémentée
cette séparation. Tu peux aussi passer par les templates où
par un autre pattern (strategy ...). C'est une question de
design.
Pour être certain de bien te comprendre : pour moi dans le
pattern strategie tu as un objet qui en agrège un autre (la
stratégie, généralement d'un type abstrait (pur ?) d'ailleurs)
et lui délègue le boulot. Comment tu mettrais ça en pratique
dans mon contexte ?
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les
prédicats de même signature mais pas de même utilisation. i.e.
tu peux avoir un prédicat qui va te servir à trier les
cellules que tu veux aggréger (première étape de l'algo), et
un autre pour les cellules que tu veux retirer (seconde étape
de l'algo).
Utiliser une classe virtuelle pure n'est pas le seul moyen
de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente
ne saurait être implémentéecette séparation. Tu peux aussi passer par les templates où
par un autre pattern (strategy ...). C'est une question de
design.
Pour être certain de bien te comprendre : pour moi dans le
pattern strategie tu as un objet qui en agrège un autre (la
stratégie, généralement d'un type abstrait (pur ?) d'ailleurs)
et lui délègue le boulot. Comment tu mettrais ça en pratique
dans mon contexte ?
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les prédicats
de même signature mais pas de même utilisation. i.e. tu peux avoir un
prédicat qui va te servir à trier les cellules que tu veux aggréger
(première étape de l'algo), et un autre pour les cellules que tu veux
retirer (seconde étape de l'algo).Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
saurait être implémentée
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
strategie tu as un objet qui en agrège un autre (la stratégie,
généralement d'un type abstrait (pur ?) d'ailleurs) et lui délègue le
boulot. Comment tu mettrais ça en pratique dans mon contexte ?
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les prédicats
de même signature mais pas de même utilisation. i.e. tu peux avoir un
prédicat qui va te servir à trier les cellules que tu veux aggréger
(première étape de l'algo), et un autre pour les cellules que tu veux
retirer (seconde étape de l'algo).
Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
saurait être implémentée
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
strategie tu as un objet qui en agrège un autre (la stratégie,
généralement d'un type abstrait (pur ?) d'ailleurs) et lui délègue le
boulot. Comment tu mettrais ça en pratique dans mon contexte ?
Tu dois vouloior dire séparer les interfaces et les implémentations.
Ce que je vais dire ici n'engage que moi (i.e. je ne prétend pas que
c'est ce qu'avait dit James, mais c'est ce que j'en avais compris).
L'idée donc pour illustrer, c'est que tu peux avoir besoin d'une paire
d'entier par exemple pour indexer les éléments d'une matrice, ou pour,
je sais pas moi les cordonnées de points dans une grille de pixels. Et
que pour plus de clarté il valait mieux se fendre de classes ou de
typedefs pour différencier :
typedef pair<int,int> MatriceIndex;
typedef pair<int,int> PointCood;
Et dans mon cas, tu vas peut être pas vouloir mélanger les prédicats
de même signature mais pas de même utilisation. i.e. tu peux avoir un
prédicat qui va te servir à trier les cellules que tu veux aggréger
(première étape de l'algo), et un autre pour les cellules que tu veux
retirer (seconde étape de l'algo).Utiliser une classe virtuelle pure n'est pas le seul moyen de faire
Si j'ai utilisé de l'abstract pur, c'est que la classe parente ne
saurait être implémentée
cette séparation. Tu peux aussi passer par les templates où par un
autre pattern (strategy ...). C'est une question de design.
Pour être certain de bien te comprendre : pour moi dans le pattern
strategie tu as un objet qui en agrège un autre (la stratégie,
généralement d'un type abstrait (pur ?) d'ailleurs) et lui délègue le
boulot. Comment tu mettrais ça en pratique dans mon contexte ?