Soll ich eine std :: -Funktion als const-Referenz übergeben?

Angenommen, ich habe eine Funktion, die Folgendes übernimmt std::function:

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

Soll ich xstattdessen durch const-reference gehen?:

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

Ändert sich die Antwort auf diese Frage abhängig davon, was die Funktion damit macht? Zum Beispiel, wenn es sich um eine Klassenelementfunktion oder einen Konstruktor handelt, der die std::functionin einer Elementvariablen speichert oder initialisiert .

Wenn Sie Leistung wünschen, übergeben Sie den Wert, wenn Sie ihn speichern.

Angenommen, Sie haben eine Funktion namens "Führen Sie dies im UI-Thread aus".

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

Das führt einen Code im "UI" -Thread aus und signalisiert dann, futurewann fertig. (Nützlich in UI-Frameworks, in denen sich der UI-Thread dort befindet, wo Sie mit UI-Elementen herumspielen sollen.)

Wir haben zwei Unterschriften, die wir in Betracht ziehen:

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

Nun werden wir diese wahrscheinlich wie folgt verwenden:

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

Dadurch wird ein anonymer Abschluss (ein Lambda) erstellt, ein std::functionOut daraus erstellt, an die run_in_ui_threadFunktion übergeben und gewartet, bis die Ausführung im Hauptthread abgeschlossen ist.

In Fall (A) wird das std::functiondirekt aus unserem Lambda konstruiert, das dann innerhalb des verwendet wird run_in_ui_thread. Das Lambda wird movein den std::functionZustand gebracht, so dass jeder bewegliche Zustand effizient in ihn hineingetragen wird.

Im zweiten Fall wird ein Temporär std::functionerstellt, das Lambda wird darin moveeingefügt, dann dieses Temporärstd::function als Referenz innerhalb des verwendet run_in_ui_thread.

So weit, so gut - die beiden arbeiten identisch. Außer das run_in_ui_threadwird eine Kopie seines Funktionsarguments erstellen, um es zur Ausführung an den UI-Thread zu senden! (Es wird zurückgegeben, bevor es damit fertig ist, daher kann es nicht einfach einen Verweis darauf verwenden.) Für Fall (A) legen wir einfach movedas std::functionin seine Langzeitlagerung. In Fall (B) sind wir gezwungen, das zu kopierenstd::function .

Dieser Laden macht die Wertübergabe optimaler. Wenn die Möglichkeit besteht, dass Sie eine Kopie von speichern std::function, übergeben Sie den Wert. Ansonsten ist jeder Weg ungefähr gleichwertig: Der einzige Nachteil des Nebenwerts besteht darin, dass Sie denselben sperrigen nehmen std::functionund eine Submethode nach der anderen verwenden. Ansonsten ist a moveso effizient wie a const&.

Nun gibt es einige andere Unterschiede zwischen den beiden, die meistens auftreten, wenn wir einen anhaltenden Zustand innerhalb der haben std::function.

Angenommen, das std::functionObjekt wird mit einem gespeichert operator() const, es enthält jedoch auch einige mutableDatenelemente, die geändert werden (wie unhöflich!).

In diesem std::function<> const&Fall werden die mutablegeänderten Datenelemente aus dem Funktionsaufruf weitergegeben. In diesem std::function<>Fall werden sie nicht.

Dies ist ein relativ seltsamer Eckfall.

Sie möchten std::functionwie jeder andere möglicherweise schwere, billig bewegliche Typ behandeln. Umzug ist billig, Kopieren kann teuer sein.

Wenn Sie sich Sorgen um die Leistung machen und keine virtuelle Mitgliedsfunktion definieren, sollten Sie diese höchstwahrscheinlich überhaupt nicht verwenden std::function.

Wenn Sie den Funktortyp zu einem Vorlagenparameter machen, können Sie ihn besser optimieren, als die std::functionFunktorlogik einzuschließen. Der Effekt dieser Optimierungen wird wahrscheinlich die Bedenken hinsichtlich der Weitergabe von Kopien und Indirektionen bei der Übergabe erheblich überwiegen std::function.

Schneller:

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

Wie in C ++ 11 üblich, hängt die Übergabe von value / reference / const-reference davon ab, was Sie mit Ihrem Argument tun. std::functionist nicht anders.

Durch Übergeben eines Werts können Sie das Argument in eine Variable verschieben (normalerweise eine Mitgliedsvariable einer Klasse):

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

    Object m_o;
};

Wenn Sie wissen, dass Ihre Funktion ihr Argument verschiebt, ist dies die beste Lösung. Auf diese Weise können Ihre Benutzer steuern, wie sie Ihre Funktion aufrufen:

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

Ich glaube, Sie kennen die Semantik von (Nicht-) Konstantenreferenzen bereits, daher werde ich den Punkt nicht näher erläutern. Wenn ich weitere Erklärungen dazu hinzufügen muss, fragen Sie einfach und ich werde aktualisieren.