Discussion :

[Davidbrcz]

Bonjour à tous.

Je post une question de conception mais assez lié au C++, ce qui me pousse à demander ici.

Pour le moment j'ai 2 fonctions foo et foo2 qui appellent respectivement bar et bar2. Or justement la seul différence entre foo et foo2 c'est l'appel à bar.

De plus la différence entre bar et ba2 est aussi très mince :
en effet, bar et bar2 doivent vérifier des données mais pas de la même façon (bar et bar2 se résument à une série de test).

Dès lors faut t'il mieux factoriser par foo et foo2 en faisant une seule fonction template avec comme paramètre un pointeur de fonction sur bar ou bar2 ou alors factoriser par bar avec un patern stratégie ?

La 1er solution est la plus facile à mettre en oeuvre mais est ce la meilleure ?

Merci.

[JolyLoic]

Difficile de répondre dans l'abstrait, en dehors de tout contexte.

S'il existe déjà une classe qui pourrait accepter le point de variabilité par une fonction virtuelle, (la classe représentant les données à vérifier, par exemple ?), j'y ajouterait probablement la fonction bar.

Si les perfs comptent, ce qui n'a ap priori pas l'air d'être le cas ici, la solution à base de template peut être à coût nul.

Si foo et bar sont des petits trucs en périphérie de l'appli, et que foo s'écrit :

Code :

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

1
2
3
4
5
6
foo()
{
  bur();
  bar();
  bir();
}

ou encore plus simplement, j'accepterais peut-être même la duplication comme étant meilleure qu'une solution plus sophistiquée, car plus simple tout en restant d'amplitude limitée.

Utiliser le pattern strategy alors qu'on ne semble pas vouloir de variabilité runtime me semble un peu lourd.

[Davidbrcz]

Donc pour rendre mon problème un peu plus concret,
foo et foo2 sont des fonctions recevant des données depuis un socket.
Elle recoivent la même chose c'est juste que foo est la fonction appellée pour recevoir la 1er fois car le test effectué par bar est différent lors du reste de l'application.

S'il existe déjà une classe qui pourrait accepter le point de variabilité par une fonction virtuelle, (la classe représentant les données à vérifier, par exemple ?), j'y ajouterait probablement la fonction bar.

Nan les fonctions virtuelles, on oubli, car foo et foo2 font partie de la même classe et sont appelées à partir du même objet.

Si les perfs comptent, ce qui n'a ap priori pas l'air d'être le cas ici, la solution à base de template peut être à coût nul.

D'après ce que j'imagine, elle l'est.

Utiliser le pattern strategy alors qu'on ne semble pas vouloir de variabilité runtime me semble un peu lourd.

J'en prend note

[jeremya]

Pour le moment j'ai 2 fonctions foo et foo2 qui appellent respectivement bar et bar2. Or justement la seul différence entre foo et foo2 c'est l'appel à bar.

De plus la différence entre bar et ba2 est aussi très mince :
en effet, bar et bar2 doivent vérifier des données mais pas de la même façon (bar et bar2 se résument à une série de test).

Peux-tu nous donner le prototype des fonctions ? Ce serait plus simple pour comprendre ton problème.

[Davidbrcz]

Après une bonne nuit de someil, j'ai décidé de factoriser par foo et donc de passer par les templates.
Ne reste plus qu'a trouver comment appeller une fonction template membre d'une classe.