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

**Aspic** · 19/11/2010, 00h28

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 :

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

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 :

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

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

Message d'eereur :

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 :

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

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

la_tupac · 19/11/2010, 01h12

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

.

**Joel F** · 19/11/2010, 07h14

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

Code :

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

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.

**Emmanuel Deloget** · 19/11/2010, 10h01

Envoyé par Joel F

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

Code :

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

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.

**Joel F** · 19/11/2010, 11h20

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

Code :

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

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;
};

**Aspic** · 19/11/2010, 12h18

Exact ca marche

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

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 !

**Emmanuel Deloget** · 19/11/2010, 12h37

Envoyé par Aspic

Exact ca marche

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

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 !

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 : )

**Aspic** · 19/11/2010, 13h50

parfait réponse très clair

**3DArchi** · 20/11/2010, 10h28

Salut,

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 ?

**Aspic** · 20/11/2010, 10h48

Bonjour,

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

Code :

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

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 :

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

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 ?

**3DArchi** · 20/11/2010, 13h04

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).