Ist Pass-by-Value in C ++ 11 ein vernünftiger Standard?

In herkömmlichem C ++ ist die Übergabe von Werten an Funktionen und Methoden für große Objekte langsam und wird im Allgemeinen verpönt. Stattdessen neigen C ++ - Programmierer dazu, Referenzen weiterzugeben, was schneller ist, aber alle möglichen komplizierten Fragen zum Besitz und insbesondere zur Speicherverwaltung aufwirft (falls das Objekt Heap-zugewiesen ist).

Jetzt haben wir in C ++ 11 Rvalue-Referenzen und Verschiebungskonstruktoren, was bedeutet, dass es möglich ist, ein großes Objekt (wie ein Objekt std::vector) zu implementieren , das kostengünstig als Wert in eine Funktion und aus einer Funktion übergeben werden kann.

Bedeutet dies also, dass der Standardwert für Instanzen von Typen wie std::vectorund als Wert übergeben werden sollte std::string? Was ist mit benutzerdefinierten Objekten? Was ist die neue Best Practice?

Dies ist eine vernünftige Standardeinstellung, wenn Sie eine Kopie im Text erstellen müssen. Dies ist, was Dave Abrahams befürwortet :

Richtlinie: Kopieren Sie Ihre Funktionsargumente nicht. Übergeben Sie sie stattdessen als Wert und lassen Sie den Compiler das Kopieren durchführen.

Im Code bedeutet dies, dass Sie Folgendes nicht tun:

void foo(T const& t)
{
    auto copy = t;
    // ...
}

aber mach das:

void foo(T t)
{
    // ...
}

Das hat den Vorteil, dass der Anrufer foowie folgt nutzen kann:

T lval;
foo(lval); // copy from lvalue
foo(T {}); // (potential) move from prvalue
foo(std::move(lval)); // (potential) move from xvalue

und es wird nur minimale Arbeit geleistet. Sie benötigen zwei Überladungen, um dasselbe mit Referenzen zu tun, void foo(T const&);und void foo(T&&);.

In diesem Sinne habe ich jetzt meine geschätzten Konstruktoren als solche geschrieben:

class T {
    U u;
    V v;
public:
    T(U u, V v)
        : u(std::move(u))
        , v(std::move(v))
    {}
};

Andernfalls constist es vernünftig, auf still zu verweisen .

In fast allen Fällen sollte Ihre Semantik entweder wie folgt sein:

bar(foo f); // want to obtain a copy of f
bar(const foo& f); // want to read f
bar(foo& f); // want to modify f

Alle anderen Unterschriften sollten nur sparsam und mit guter Begründung verwendet werden. Der Compiler wird diese nun so gut wie immer auf die effizienteste Weise herausarbeiten. Sie können einfach mit dem Schreiben Ihres Codes fortfahren!

Übergeben Sie Parameter als Wert, wenn Sie innerhalb des Funktionskörpers eine Kopie des Objekts benötigen oder nur das Objekt verschieben müssen. Übergeben const&Sie, wenn Sie nur nicht mutierenden Zugriff auf das Objekt benötigen.

Beispiel für eine Objektkopie:

void copy_antipattern(T const& t) { // (Don't do this.)
    auto copy = t;
    t.some_mutating_function();
}

void copy_pattern(T t) { // (Do this instead.)
    t.some_mutating_function();
}

Beispiel für Objektverschiebung:

std::vector<T> v; 

void move_antipattern(T const& t) {
    v.push_back(t); 
}

void move_pattern(T t) {
    v.push_back(std::move(t)); 
}

Beispiel für einen nicht mutierenden Zugriff:

void read_pattern(T const& t) {
    t.some_const_function();
}

Weitere Informationen finden Sie in diesen Blog-Beiträgen von Dave Abrahams und Xiang Fan .

Die Signatur einer Funktion sollte den Verwendungszweck widerspiegeln. Die Lesbarkeit ist auch für den Optimierer wichtig.

Dies ist die beste Voraussetzung für einen Optimierer, um den schnellsten Code zu erstellen - zumindest theoretisch und wenn nicht in der Realität, dann in einigen Jahren Realität.

Leistungsüberlegungen werden im Zusammenhang mit der Parameterübergabe sehr oft überbewertet. Perfekte Weiterleitung ist ein Beispiel. Funktionen wie emplace_backsind meistens sehr kurz und sowieso inline.