Devo passare una funzione std :: tramite const-reference?

Diciamo che ho una funzione che accetta un std::function:

void callFunction(std::function<void()> x)
{
    x();
}

Dovrei invece passare xper const-reference ?:

void callFunction(const std::function<void()>& x)
{
    x();
}

La risposta a questa domanda cambia a seconda di ciò che la funzione fa con essa? Ad esempio, se è una funzione o un costruttore di un membro di classe che archivia o inizializza la std::functionvariabile in un membro.

Se desideri prestazioni, passa per valore se le stai memorizzando.

Supponiamo di avere una funzione chiamata "esegui questo nel thread dell'interfaccia utente".

std::future<void> run_in_ui_thread( std::function<void()> )

che esegue del codice nel thread "ui", quindi segnala il completamento future. (Utile nei framework dell'interfaccia utente in cui il thread dell'interfaccia utente è il punto in cui dovresti pasticciare con gli elementi dell'interfaccia utente)

Abbiamo due firme che stiamo prendendo in considerazione:

std::future<void> run_in_ui_thread( std::function<void()> ) // (A)
std::future<void> run_in_ui_thread( std::function<void()> const& ) // (B)

Ora, è probabile che utilizzeremo questi come segue:

run_in_ui_thread( [=]{
  // code goes here
} ).wait();

che creerà una chiusura anonima (un lambda), ne costruirà uno std::functionfuori, lo passerà alla run_in_ui_threadfunzione, quindi attenderà che finisca l'esecuzione nel thread principale.

Nel caso (A), il std::functionè direttamente costruito dal nostro lambda, che viene quindi utilizzato all'interno del file run_in_ui_thread. Il lambda è moved in std::function, quindi ogni stato mobile viene efficacemente trasportato in esso.

Nel secondo caso, std::functionviene creato un temporaneo , il lambda è moved in esso, quindi quel temporaneo std::functionviene utilizzato come riferimento all'interno di run_in_ui_thread.

Fin qui tutto bene - i due si esibiscono in modo identico. Tranne che run_in_ui_threadsta per fare una copia del suo argomento di funzione da inviare al thread dell'interfaccia utente per l'esecuzione! (tornerà prima di averlo fatto, quindi non può semplicemente usare un riferimento ad esso). Per il caso (A), ci limitiamo semplicemente movealla std::functionsua conservazione a lungo termine. Nel caso (B), siamo costretti a copiare il file std::function.

Quel negozio rende il passaggio per valore più ottimale. Se è possibile che tu stia memorizzando una copia di std::function, passa per valore. Altrimenti, in entrambi i casi è approssimativamente equivalente: l'unico aspetto negativo del per valore è se stai prendendo lo stesso ingombrante std::functione hai un metodo secondario dopo l'altro usarlo. A parte questo, a movesarà efficiente quanto a const&.

Ora, ci sono alcune altre differenze tra i due che entrano principalmente se abbiamo uno stato persistente all'interno di std::function.

Supponiamo che std::functionmemorizzi un oggetto con a operator() const, ma ha anche alcuni mutablemembri di dati che modifica (che maleducato!).

Nel std::function<> const&caso, i mutablemembri dei dati modificati si propagheranno fuori dalla chiamata di funzione. Nel std::function<>caso, non lo faranno.

Questo è un caso angolare relativamente strano.

Vuoi trattare std::functioncome qualsiasi altro tipo possibilmente pesante, a buon mercato mobile. Lo spostamento è economico, la copia può essere costosa.

Se sei preoccupato per le prestazioni e non stai definendo una funzione membro virtuale, molto probabilmente non dovresti usare std::functionaffatto.

Rendere il tipo di funzione un parametro modello consente un'ottimizzazione maggiore rispetto std::function, incluso l'inserimento della logica del funzione. È probabile che l'effetto di queste ottimizzazioni superi di gran lunga le preoccupazioni di copia contro indiretta su come passare std::function.

Più veloce:

template<typename Functor>
void callFunction(Functor&& x)
{
    x();
}

Come al solito in C ++ 11, passare per valore / riferimento / const-riferimento dipende da cosa fai con il tuo argomento. std::functionnon è diverso.

Il passaggio per valore consente di spostare l'argomento in una variabile (in genere una variabile membro di una classe):

struct Foo {
    Foo(Object o) : m_o(std::move(o)) {}

    Object m_o;
};

Quando sai che la tua funzione sposterà il suo argomento, questa è la soluzione migliore, in questo modo i tuoi utenti possono controllare come chiamano la tua funzione:

Foo f1{Object()};               // move the temporary, followed by a move in the constructor
Foo f2{some_object};            // copy the object, followed by a move in the constructor
Foo f3{std::move(some_object)}; // move the object, followed by a move in the constructor

Credo che tu conosca già la semantica dei (non) riferimenti costanti, quindi non voglio chiarire il punto. Se hai bisogno che io aggiunga ulteriori spiegazioni al riguardo, basta chiedere e aggiornerò.