Vermeiden kopieren von Objekten mit der "return" - Anweisung

Scheint es einige Verwirrung darüber, wie die RVO (Return Value Optimization) funktioniert.

Einem einfachen Beispiel:

#include <iostream>

struct A {
    int a;
    int b;
    int c;
    int d;
};

A create(int i) {
    A a = {i, i+1, i+2, i+3 };
    std::cout << &a << "\n";
    return a;
}

int main(int argc, char*[]) {
    A a = create(argc);
    std::cout << &a << "\n";
}

Und seine Ausgabe an ideone:

0xbf928684
0xbf928684

Überraschend ?

Tatsächlich, das ist der Effekt, der RVO: das Objekt zurückgegeben werden wurde direkt im Ort in die Anrufer.

Wie ?

Traditionell, der Anrufer (main hier) Reservierung von Speicherplatz auf dem stack für return-Wert: der Rückkehr slot; die aufgerufene (create hier) übergeben wird (irgendwie) die Adresse des return-slot zu kopieren Sie den Rückgabewert an. Der angerufene dann reservieren Sie einen eigenen Bereich für die lokale variable, in dem es erstellt das Ergebnis, wie für jede andere lokale variable verwenden, und dann kopiert diese in die return-slot auf der return - Anweisung.

RVO wird ausgelöst, wenn der compiler leitet sich vom code, der die variable erstellt werden können, direkt in die Rückkehr slot mit gleicher Semantik (als-ob-Regel).

Beachten Sie, dass dies solche gemeinsame Optimierung, es ist ausdrücklich in der weißen Liste aufgeführt, die von der Standard-und der compiler nicht haben, um sorgen über mögliche Nebenwirkungen der copy (oder move) Konstruktor.

Wann ?

Der compiler wird höchstwahrscheinlich mit einfachen Regeln, wie:

//1. works
A unnamed() { return {1, 2, 3, 4}; }

//2. works
A unique_named() {
    A a = {1, 2, 3, 4};
    return a;
}

//3. works
A mixed_unnamed_named(bool b) {
    if (b) { return {1, 2, 3, 4}; }

    A a = {1, 2, 3, 4};
    return a;
}

//4. does not work
A mixed_named_unnamed(bool b) {
    A a = {1, 2, 3, 4};

    if (b) { return {4, 3, 2, 1}; }

    return a;
}

Im letzteren Fall (4), die Optimierung nicht angewendet werden, wenn A zurückgegeben wird, weil der compiler nicht bauen kann a in der return-slot, wie er es brauchen kann für etwas anderes (je nach der Boolesche Bedingung b).

Eine einfache Faustregel ist so, dass:

RVO angewandt werden sollte, wenn kein anderer Kandidat für die Rückkehr slot erklärt wurde, vor der return - Anweisung.

Compiler oft optimieren können entfernt werden die extra-Kopie für Sie (dies ist bekannt als return-Wert-Optimierung). Sehen https://isocpp.org/wiki/faq/ctors#return-by-value-optimization

Der move-Konstruktor ist garantiert verwendet werden, wenn NRVO nicht passieren

Daher, wenn Sie ein Objekt zurückgeben, mit move-Konstruktor (wie std::vector) von Wert ist, ist es garantiert nicht zu tun, eine vollständige Vektor-Kopie, selbst wenn der compiler nicht die optionale NRVO-Optimierung.

Diese wird wie erwähnt durch zwei Benutzer erscheinen einflussreich in der C++ - Spezifikation selbst:

• Johathan Wakely bei Ist ein Objekt gewährleistet werden verschoben, wenn Sie zurückgegeben wird?
• Howard Hinnant Gewusst wie: zurückgeben eines Objekts aus einer Funktion unter Berücksichtigung von C++11 rvalues und move-Semantik?

Nicht zufrieden mit mein Appell an Berühmtheit?

OK. Kann ich nicht ganz verstehen, die C++ - standard, aber ich kann verstehen, dass die Beispiele, die es hat! 😉

Unter Angabe der C++17 n4659 standard-Entwurf 15.8.3 [Klasse.kopieren.elision] "Kopieren/verschieben elision"

3 In der folgenden copy-Initialisierung von Kontexten, eine move-operation verwendet werden könnten, anstatt eine kopieren-operation:

• (3.1) — Wenn der Ausdruck in der return-Anweisung (9.6.3) ist ein (eventuell eingeklammerte) id-expression, die Namen
  ein Objekt mit automatischer Speicherdauer erklärt, in den Körper oder parameter-Erklärung-Klausel der
  innersten umschließenden Funktion oder ein lambda-Ausdruck oder
• (3.2) — wenn der operand ein throw-Ausdruck (8.17) ist der name eines nicht-flüchtigen automatic object (andere als
  eine Funktion oder catch-Klausel parameter), deren Gültigkeitsbereich erstreckt sich nicht über das Ende der innersten
  umschließenden try-block (wenn es eine ist),

überlast Auflösung wählen Sie den Konstruktor für die Kopie wird zuerst durchgeführt, als ob das Objekt bezeichnet wurden
durch eine rvalue. Wenn der erste überlast Auflösung fehlschlägt oder nicht durchgeführt wurde, oder wenn der Typ des ersten Parameters
der gewählte Konstruktor nicht eine rvalue-Referenz auf den Typ des Objekts (möglicherweise cv-qualifiziert), überlast
Auflösung erfolgt wieder, wenn man bedenkt das Objekt als ein lvalue. [ Hinweis: Dieser zwei-Stufen-überlast Auflösung
muss durchgeführt werden, unabhängig davon, ob copy elision eintreten wird. Es bestimmt der Konstruktor aufgerufen wird, wenn
elision ist nicht durchgeführt, und der gewählte Konstruktor muss zugänglich sein, auch wenn der Anruf erstellte. — Ende
Hinweis ]

4 [ Beispiel:

class Thing {
public:
  Thing();
  ~ Thing();
  Thing(Thing&&);
private:
  Thing(const Thing&);
};

Thing f(bool b) {
  Thing t;
  if (b)
    throw t;          //OK: Thing(Thing&&) used (or elided) to throw t
  return t;           //OK: Thing(Thing&&) used (or elided) to return t
}

Thing t2 = f(false);  //OK: no extra copy/move performed, t2 constructed by call to f

struct Weird {
  Weird();
  Weird(Weird&);
};

Weird g() {
  Weird w;
  return w;           //OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
}

— end-Beispiel

Ich weiß nicht, wie das "benutzt werden könnte" Wortwahl, aber ich denke, die Absicht ist, bedeuten, dass, wenn entweder "3.1" oder "3.2" halten, dann die rvalue zurück passieren müssen.

Dies ist ziemlich klar, auf die Kommentare im code für mich.

Pass by reference + std::vector.resize(0) für mehrere Anrufe

Wenn Sie mehrere Aufrufe test, ich glaube, das wäre etwas effizienter als es spart ein paar malloc() Anrufe + Umzug kopiert, wenn der Vektor verdoppelt in der Größe:

void test(const unsigned int n, std::vector<int>& x) {
    x.resize(0);
    x.reserve(n);
    for (unsigned int i = 0; i < n; ++i) {
        x.push_back(i);
    }
}

std::vector<int> x;
test(10, x);
test(20, x);
test(10, x);

gegeben, dass https://en.cppreference.com/w/cpp/container/vector/resize sagt:

Vektor-Kapazität ist nie reduziert, wenn die Größenanpassung auf kleinere Größe, weil das würde ungültig alle Iteratoren, statt nur diejenigen, die würde für ungültig erklärt werden, von der entsprechenden Sequenz von pop_back () - Aufrufe.

und ich glaube nicht, dass Compiler sind in der Lage zur Optimierung des return-by-value-version um zu verhindern, dass die extra mallocs.

Auf der anderen Seite:

• macht die Schnittstelle hässlicher
• verwendet mehr Speicher als nötig, wenn Sie verringern Sie die Vektor-Größe

so, es ist ein trade-off.