il passaggio lambda in base al valore o al riferimento rende più semplice l'inline?

Question

Un simile question è stato chiesto prima, ma sono ancora confuso. L'STL, credo, passa esclusivamente per valore, in quanto il passaggio per riferimento potrebbe avere conseguenze in un ambiente multi-thread. Dì, quando due o più thread eseguono un lambda mutabile. Attualmente uso un riferimento universale, quando voglio solo richiamare un lambda:

template <typename F> 
inline void invoke(F&& f) 
{ 
    f(); 
} 

Questo si lega a qualsiasi oggetto funzione, proprio come una const& sarebbe, ma forse è una cattiva idea per inline. Un lambda passato per copia è più facile da incorporare dal compilatore? Mi piacerebbe che il lambda passato fosse il più "inelegabile" possibile.

Answer 1

pensare ad un lambda come un piccolo oggetto con un operatore funzione di chiamata:

int foo = 1000; 
auto f = [=]() ->int { return foo; }; 

è in qualche modo equivalente a:

class FooLambda { 
    int foo; 
    public: 
    FooLambda(int foo) : foo(foo) {} 
    int operator()(){ return foo; } 
}; 
// ... 
int foo = 1000; 
FooLambda f(foo); 

Quindi, vedete, il corpo della funzione stessa può essere inline se è visto nella stessa unità di traduzione come viene chiamata (e forse se non da alcuni compilatori più intelligenti). Dato che il tuo invoke è un modello, conosce il tipo effettivo di lamdba e non lo imponi di saltare attraverso i cerchi di puntatore di funzioni, che è un grande inibitore dell'inallineamento.

Prendendo l'oggetto richiamabile per valore o riferimento in invoke determina se le variabili acquisite sono locali al corpo della funzione o no, che può fare la differenza se questo significa che sarà nella cache.