Supposons un prédicat (ou foncteur) comme ceci:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
struct pred
{
 bool operator(Ob const & rl,Ob const & rr) const
 {
   resource tmp_r;
   int il=rl.foo(tmp_r);
   int ir=rr.foo(tmp_r);
   return il < ir;
 }
};
En gros cela signifie que j'ai besoin d'une resource assez "lourde" mais qui reste temporaire et à usage local uniquement.

Afin d'éviter sa construction et destruction à chaque passage dans le foncteur, je pense qu'il est préférable de faire comme ceci:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
struct pred
{
 resource tmp_r;
 bool operator(Ob const & rl,Ob const & rr) const
 {
   tmp_r.clear();
   int il=rl.foo(tmp_r);
   int ir=rr.foo(tmp_r);
   return il < ir;
 }
};
Ceci étant, ce n'est peut-être pas encore assez satisfaisant car les foncteurs sont toujours passés par valeur à l'intérieur des méandres de la SL, avec recopie probable de la resource tmp_r à chaque fois.

Il y a une troisième solution:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
struct pred
{
 resource & tmp_r;
 pred(resource & r=resource()):tmp_r(r) {}
 bool operator(Ob const & rl,Ob const & rr) const
 {
   tmp_r.clear();
   int il=rl.foo(tmp_r);
   int ir=rr.foo(tmp_r);
   return il < ir;
 }
};
Cette troisième écriture semble bonne car la resource n'est créée qu'une fois puis "déplacée" à chaque copie du prédicat, mais elle ne me satisfait pourtant pas pleinement (sans que je puisse dire pourquoi).
A priori je préfère la 2ème écriture, mais les compilateurs sont-ils assez intelligents dans l'optimisation en mode release pour comprendre que les fonctions de la SL, fonctions inline pour la plupart, une fois mises à "plat" (ou défactorisées, je ne sais pas comment dire), le prédicat passé par valeur est en fait toujours le même ? Sont-ils capables de comprendre qu'il suffit de "déplacer" le predicat plutôt que d'en faire une copie à chaque appel de fonction ?