Pass by value vs. pass by rvalue-Referenz

Es sei denn, der Typ ist ein bewegen-nur geben Sie normalerweise eine option, um pass by reference-to-const, und es scheint willkürlich zu machen, "nicht Teil der Diskussion", aber ich werde es versuchen.

Ich denke, dass die Wahl teilweise, hängt davon ab, was foo ist jetzt mit dem parameter.

Muss die Funktion eine lokale Kopie

Sagen wir mal Widget ist ein iterator und Sie möchten, um Ihre eigenen std::next Funktion. next braucht seine eigene Kopie Voraus und kehrt dann zurück. In diesem Fall ist die Wahl ist so etwas wie:

Widget next(Widget it, int n = 1){
    std::advance(it, n);
    return it;
}

vs

Widget next(Widget&& it, int n = 1){
    std::advance(it, n);
    return std::move(it);
}

Ich denke-Wert ist hier besser. Aus der Signatur kannst du es sehen, ist eine Kopie. Wenn der Anrufer vermeiden will, eine Kopie, die Sie tun können, eine std::move und garantieren die variable verschoben wird, aber Sie kann immer noch passieren lvalues, wenn Sie wollen.
Mit übergabe per rvalue-Referenz der Anrufer kann nicht garantieren, dass die variable verschoben wurde.

Move-Zuweisung eine Kopie

Lassen Sie uns sagen, Sie haben eine Klasse WidgetHolder:

class WidgetHolder {
    Widget widget;
   //...
};

und Sie implementieren müssen, um eine setWidget member-Funktion. Ich nehme an, Sie haben bereits eine überlastung, übernimmt eine Referenz auf const:

WidgetHolder::setWidget(const Widget& w) {
    widget = w;
}

aber nach der Messung der Leistung, die Sie entscheiden, dass Sie brauchen, um eine Optimierung für die r-Werte. Sie haben dabei die Wahl, ihn zu ersetzen mit:

WidgetHolder::setWidget(Widget w) {
    widget = std::move(w);
}

Oder überlastung mit:

WidgetHolder::setWidget(Widget&& widget) {
    widget = std::move(w);
}

Dieser ist ein wenig komplizierter. Es ist verlockend, wählen Sie " pass-by-value, weil es akzeptiert sowohl rvalues und lvalues, so brauchen Sie nicht zwei überladungen. Es ist jedoch unbedingt unter eine Kopie, so können Sie nicht nutzen alle vorhandenen Kapazitäten in den member-Variablen. Die übergabe per Referenz zu const, und übergeben Sie durch den r-Wert-Referenz überlastungen verwenden Zuordnung, ohne dass eine Kopie, die schneller sein

Bewegen-Konstrukt eine Kopie

Nun können sagen, Sie sind das schreiben der Konstruktor für WidgetHolder und nach wie vor haben Sie bereits implementiert einen Konstruktor eine Referenz auf const:

WidgetHolder::WidgetHolder(const Widget& w) : widget(w) {
}

und bevor du gemessen hast peformance und beschlossen, die Sie benötigen, um eine Optimierung für rvalues. Sie haben dabei die Wahl, ihn zu ersetzen mit:

WidgetHolder::WidgetHolder(Widget w) : widget(std::move(w)) {
}

Oder überlastung mit:

WidgetHolder::WidgetHolder(Widget&& w) : widget(std:move(w)) {
}

In diesem Fall die member-variable kann nicht über vorhandene Kapazitäten, denn dies ist der Konstruktor. Sie sind bewegen-constucting eine Kopie. Auch Konstruktoren nehmen oft viele Parameter, so kann es durchaus ein Schmerz zu schreiben, all die verschiedenen Permutationen von überlastungen zu optimieren, für r-Wert-Referenzen. Also in diesem Fall ist es eine gute Idee, pass-by-value, vor allem, wenn der Konstruktor nimmt viele dieser Parameter.

Vorbei unique_ptr

Mit unique_ptr die Effizienz betrifft sind weniger wichtig, da ein Umzug ist so Billig und es besteht keine Kapazität. Wichtiger ist die Aussagekraft und Richtigkeit. Es gibt eine gute Diskussion darüber, wie das passieren unique_ptr hier.

Wenn Sie pass von rvalue-Referenz Objekt-Lebenszeiten kompliziert. Wenn der angerufene nicht bewegen, aus dem argument, die Zerstörung der argument verzögert. Ich denke, das ist interessant, in beiden Fällen.

Ersten, Sie haben eine RAII Klasse

void fn(RAII &&);

RAII x{underlying_resource};
fn(std::move(x));
//later in the code
RAII y{underlying_resource};

Beim initialisieren y, die Ressource konnte noch gehalten werden, indem x wenn fn bewegt sich nicht aus der rvalue-Referenz. In der pass-by-value-code, wir wissen, dass x bewegt wird, und fn releases x. Dies ist wahrscheinlich ein Fall, wo Sie möchten, um durch Wert übergeben, und der copy-Konstruktor würde wahrscheinlich gelöscht werden, so dass Sie nicht haben, um sorgen über die versehentliche Kopien.

Zweite, wenn das argument ein großes Objekt und die Funktion bewegt sich nicht aus, die Lebensdauer der Vektoren Daten ist größer als im Falle von durch Wert übergeben.

vector<B> fn1(vector<A> &&x);
vector<C> fn2(vector<B> &&x);

vector<A> va;  //large vector
vector<B> vb = fn1(std::move(va));
vector<C> vc = fn2(std::move(vb));

In dem obigen Beispiel, wenn fn1 und fn2 bewegen sich nicht aus x, dann werden Sie am Ende mit allen Daten in allen Vektoren noch am Leben. Wenn Sie stattdessen durch Wert übergeben, wird nur die Letzte Vektor die Daten werden noch am Leben sein (vorausgesetzt, Vektoren move-Konstruktor löscht den Quellen-Vektor).

Wahl zwischen by value und by-rvalue-ref -, nicht mit anderen überladungen, ist nicht sinnvoll.

Mit pass-by-value das eigentliche argument ein lvalue-Ausdruck.

Mit pass durch rvalue-ref das eigentliche argument ist ein rvalue.

Wenn die Funktion speichert eine Kopie des Arguments, dann eine vernünftige Wahl zwischen pass-by-value, und eine Reihe von überladungen mit pass-by-ref-auf-const und die übergabe per rvalue-ref. Für ein rvalue-Ausdruck als Tatsächliches argument der Satz von überlastungen vermeiden kann man verschieben. Es ist ein engineering-Darm-feeling Entscheidung, ob der micro-Optimierung lohnt sich die zusätzliche Komplexität und mit der Eingabe.