Supposons un prédicat (ou foncteur) comme ceci:En gros cela signifie que j'ai besoin d'une resource assez "lourde" mais qui reste temporaire et à usage local uniquement.
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; } };
Afin d'éviter sa construction et destruction à chaque passage dans le foncteur, je pense qu'il est préférable de faire comme ceci: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.
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; } };
Il y a une troisième solution: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).
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; } };
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 ?
Partager