[C++] Créer une fonction template avec argument

Bonsoir,

J'ai défini des classes qui possèdent toute une méthode afficher(param p).

Etant donné que j'utilise des std::vector, j'ai eu l'idée de créer une fonction template pour appeller la fonction afficher(param p) quelque soit la classe :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct Afficher { /*Afficher(const BITMAP*& zoneJeu) zoneJeu(zoneJeu) {}*/ template <class T> void operator ()(T*& p, BITMAP* zoneJeu) const { p->afficher(zoneJeu); } /*   private:   BITMAP* zoneJeu;*/ };

---

Et l'appel :

Code:

---

for_each(tabVector.begin(), tabVector.end(), Afficher(zoneJeu));

---

Message d'eereur :

Citation:

---

no matching function for call to `Afficher::Afficher(BITMAP*&)'|

---

Ca ne fonctionne pas, j'ai testé des variantes en commentaire.

Le but est de remplacer des fonctions du genre :

Code:

---

1 2 3 4 5 6 7 8 9

for (unsigned int i=0; i<tab1.size(); i++) { tab1[i]->afficher(zoneJeu); } for (unsigned int i=0; i<tab2.size(); i++) { tab2[i]->afficher(zoneJeu); }

---

Voilà merci :) et bonne soirée

Salut, il me semble ce que tu essaye de faire c'est un overload du constructeur, non? Je ne suis pas un pro mais je crois aussi qu'il est impossible de procéder ainsi.
Je peux me tromper mais le p->afficher() n'aura pas la même valeur en tant que pointeur de fonction si la class est diférente.
Perso j'utilise dynamic_cast avec diférents types et si le retour est non null je place l'appel à p->afficher(). C'est surement un peu lourd mais ça fonctionne ;).

tupac, non, encore heureux qu'on puisse surcharger le ctor ..

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct Afficher { Afficher(const BITMAP*& zoneJeu) : zoneJeu(zoneJeu) {} template <class T> void operator ()(T*& p, BITMAP* zoneJeu) const { p->afficher(zoneJeu); }   private: BITMAP* zoneJeu; };

---

devrait fonctionner. Je pense que tu avais oublier le : dans la liste d'initialiation.

Donnes quand meme le code de afficher et des classes stockées dans ton vector.

Citation:

---

Envoyé par Joel F

tupac, non, encore heureux qu'on puisse surcharger le ctor ..

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct Afficher { Afficher(const BITMAP*& zoneJeu) : zoneJeu(zoneJeu) {} template <class T> void operator ()(T*& p, BITMAP* zoneJeu) const { p->afficher(zoneJeu); }   private: BITMAP* zoneJeu; };

---

devrait fonctionner. Je pense que tu avais oublier le : dans la liste d'initialiation.

Donnes quand meme le code de afficher et des classes stockées dans ton vector.

---

Pourquoi est-ce que l'operator() prends deux arguments ? for_each() appelle le functor avec un seul argument, donc ça ne pourra pas marcher.

Ensuite, passer une référence sur un pointeur, ce n'est pas utile - d'autant que le pointeur n'est pas modifié dans la fonction.

effectivement, j'ai juste corrigée l'erreur sur le liste d'init. Ca m'apprendra a posté a 7h14 :E

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct Afficher { Afficher(const BITMAP*& zoneJeu) : zoneJeu(zoneJeu) {} template <class T> void operator ()(T const& p) const { p.afficher(zoneJeu); }   private: BITMAP* zoneJeu; };

---

Exact ca marche ;)

J'avais vu l'erreur dans le foncteur ce matin mais j'ai oublié de posté la solution :D

Cependant juste une question : Quel est l'intérêt d'utiliser des foncteurs plutôt que d'utiliser des for ? Est ce que c'est plus performant ?

Merci ! :ccool:

Citation:

---

Envoyé par Aspic

Exact ca marche ;)

J'avais vu l'erreur dans le foncteur ce matin mais j'ai oublié de posté la solution :D

Cependant juste une question : Quel est l'intérêt d'utiliser des foncteurs plutôt que d'utiliser des for ? Est ce que c'est plus performant ?

Merci ! :ccool:

---

C'est plus générique. C'est tout. La question de la performance ne se pose que lorsqu'un problème de performance est identifié. Là, tu gagnes de l'ordre de 0,000 millisecondes à l'exécution. En nanosecondes, il y a peut-être une différence.

Parmi les gains notables, le fait de déplacer le traitement dans un foncteur permet de:

1) paramétrer l'opération effectuée dans le boucle, sans pour autant faire de test. Le code est plus générique.
2) externaliser cette opération. Le code n'étant plus local la fonction est plus courte à lire, à debugger, etc. Le code est plus maintenable.
3) utiliser un algorithme générique, vérifié et revérifié par d'autres, pour le parcours de la boucle. Le code est plus robuste.

La généricité apportée permets en outre de changer le comportement de la boucle sans changer la boucle elle-même. On évite ainsi les risques de régression qui pourraient être liées à une petite erreur dans la mise à jour du code.

Bref, c'est beaucoup de bénéfice.

Au niveau du code lui même : il y a de grandes chances que for_each() soit inliné, de même que le code su foncteur. Au final,le codé généré sera au pire identique à celui qui aurait été généré si tu avais écrit (correctement) la boucle.

Donc pour résumer : tu n'y perds rien, et tu y gagne beaucoup : )

parfait réponse très clair :ccool:

Salut,

Citation:

---

Envoyé par Emmanuel Deloget

Parmi les gains notables, le fait de déplacer le traitement dans un foncteur permet de:

1) paramétrer l'opération effectuée dans le boucle, sans pour autant faire de test. Le code est plus générique.
2) externaliser cette opération. Le code n'étant plus local la fonction est plus courte à lire, à debugger, etc. Le code est plus maintenable.
3) utiliser un algorithme générique, vérifié et revérifié par d'autres, pour le parcours de la boucle. Le code est plus robuste.

---

Souvent le foncteur est quand même une 'obligation' pour avoir un objet callable qu'un réel besoin de design. A ce titre les lambdas permettent de 'relocaliser' le traitement effectif d'un algo générique en évitant la multiplication des petits objets foncteurs.
Par exemple, ici, Afficher est probablement appelée à un moment où on veut afficher et pas faire autre chose. Donc le foncteur n'est probablement pas un point de variation de la fonction. Et si on pouvait s'en passer, ce ne serait que mieux, non ?

Bonjour,

En fait je possède plusieurs classes avec toute une fonction afficher().
Et j'ai aussi plusieurs vector de ses classes :

Code:

---

1 2	vector<class1*> tab1; vector<class2*> tab2;

---

Et au début je faisais toujours le même boucle pour parcourir mes objets et les afficher:

Code:

---

1 2 3 4 5

for (unsigned int i=0; i<tab1.size(); i++) { tab1[i]->afficher(zoneJeu); }

---

Pourquoi le foncteur ne serait-il pas adapter dans mon cas ?

Citation:

---

Envoyé par Aspic

Pourquoi le foncteur ne serait-il pas adapter dans mon cas ?

---

Je réagissait plus à l'intervention d'Emmanuel qui à mon sens pouvait être comprise de façon trop générale. Pour ton problème, le foncteur explicite, mais aussi les lambdas ou des boost.bind (qui sont des aides à construire des foncteurs) avec un algo générique de type std::for_each parait approprié. Mais l'objet foncteur est ici ce qui te permet de créer un objet callable (on peut appliquer l'opérateur ()) avec un contexte (ici, l'appel avec this). Le foncteur ne crée pas un élément de design intéressant en soi. Dans les fonctions où tu fait ton std::for_each avec ton foncteur, le foncteur ne sera jamais amené à changer (alors que les implémentations de afficher() probablement que oui).

Citation:

---

Envoyé par 3DArchi

Je réagissait plus à l'intervention d'Emmanuel qui à mon sens pouvait être comprise de façon trop générale.

---

Oki ;)

Je ne pensais pas que le C++ était aussi compliqué :D il y a tellement de possibilité pour un problème donnée. Je ne connais pas encore les lambdas mais j'irais me renseigner.

Merci