Discussion :

[camboui]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
bool MaFonctionDeTri(const type & rl,const type & rr)
{
return rl < rr;
}
 
struct MonFoncteurDeTri
{
bool operator()(const type & rl,const type & rr)
{
return rl < rr;
}
};

Je trouve la seconde écriture assez lourde et moins lisible.
Dans quel cas est-il avantageux de l'utiliser lorsqu'on a un prédicat à passer en paramètre à une fonction de <algorithm> ?
Merci pour vos retours d'expérience.

[Laurent Gomila]

L'opérateur () d'une structure est résolu à la compilation et peut être inliné, alors qu'un pointeur sur fonction laissera toujours une indirection à l'exécution et empêchera toute optimisation.

Dans certains cas cela a peu d'importance, dans d'autres cela en a énormément (utilise std::sort avec les deux, tu verras ).

De plus, un foncteur peut porter un contexte (via ses données membres), ce que ne peut pas faire une fonction non-membre.

[loufoque]

L'opérateur () d'une structure est résolu à la compilation et peut être inliné, alors qu'un pointeur sur fonction laissera toujours une indirection à l'exécution et empêchera toute optimisation.

Les deux peuvent tout aussi bien être optimisés. Il me semble qu'à une époque il y avait un bug dans GCC qui lui empêchait d'optimiser les pointeurs de fonctions, mais y'a pas de raison pour que l'un s'optimise et pas l'autre.

Utiliser un foncteur permet d'avoir autre chose qu'une fonction libre, et donc d'avoir en particulier un contexte et un état.
Ça permet aussi de fournir différentes surcharges.

[JolyLoic]

Les deux peuvent tout aussi bien être optimisés.

C'est vrai en théorie. En pratique, il semble que ce soit bien plus simple dans un cas que dans l'autre.

[r0d]

L'utilisation d'un foncteur plutôt qu'une fonction libre peut être aussi agréable lorsque le code qu'il doit contenir est important et qu'il doit donc être découpé en sous-fonctions. Dans le cas d'une fonction libre, on va se retrouver avec tout un tas de fonctions libres. Personellement, je n'aime pas trop ça. Alors qu'avec un foncteur, on peut tout mettre dans un foncteur ( et éventuellement utiliser la ruse décrite ici ). Mais bon, là c'est assez subjectif.

[Sylvain Togni]

Tout a fait. Je viens d'essayer avec VC2005 et GCC 3.4.4, dans les deux cas std::sort avec une fonction est environ deux fois plus lent que std::sort avec un foncteur.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <ctime>
 
inline bool fonction(int a, int b)
{
  return a < b;
}
 
struct Foncteur
{
  bool operator()(int a, int b) const
  {
    return a < b;
  }
};
 
int main()
{
  int const n = 1000;
  int v0[n];
  for(int i = 0; i < n; ++i)
  {
    v0[i] = std::rand();
  }
  int v[n];
  for(int j = 0; j < 5; ++j)
  {
    std::clock_t t0 = std::clock();
    for(int k = 0; k < 10000; ++k)
    {
      std::copy(v0, v0 + n, v);
      std::sort(v, v + n, fonction);
    }
    std::cout << double(std::clock() - t0)/CLOCKS_PER_SEC << '\n';
  }
}

[camboui]

Sous VC++6 le foncteur est 4-5% plus rapide. Bien que ce soit peu significatif, c'est tout de même surprenant de ne pas avoir les mêmes performances !

Bon ben va pour le foncteur() alors