std::move vs. std::forward: Wann sollte ich beide für eine perfekte Weiterleitung verwenden?

std::Move vs. std::Forward: R-Wert-Semantik verstehen

In der C-Programmierung spielen R-Wert-Referenzen und temporäre Objekte eine entscheidende Rolle Rolle bei der Optimierung der Codeleistung. Zwei Schlüsselfunktionen, std::move und std::forward, werden verwendet, um diese Entitäten zu manipulieren.

std::Move

Std::move akzeptiert ein Objekt nach Wert und behandelt ihn als temporären Wert (r-Wert). Normalerweise machen Funktionen, die R-Wert-Referenzen annehmen, das ursprüngliche Objekt nach der Verwendung ungültig. Durch die Verwendung von std::move geben Sie explizit an, dass das Objekt nicht mehr verwendet werden soll und ihm ein neuer Wert zugewiesen werden kann.

std::Forward

Std::forward dient einem einzigartigen Zweck: einen auf Vorlagen basierenden Funktionsparameter in dieselbe Wertkategorie (L-Wert oder R-Wert) umzuwandeln, die der Aufrufer beabsichtigt hat. Dies ermöglicht eine „perfekte Weiterleitung“, sodass R-Wert-Argumente als R-Werte und L-Werte als L-Werte übergeben werden können.

Hauptunterschiede

• Std::forward behält die Werte des Objekts bei Lebensdauer, während std::move impliziert, dass das Objekt sein wird ungültig gemacht.
• Std::forward wird in Funktionsvorlagen verwendet, um einen Parameter an eine andere Funktion weiterzuleiten und dabei seine Wertkategorie beizubehalten.
• Std::move wird normalerweise verwendet, um anzugeben, dass das Objekt temporär ist und sollte nicht weiter verwendet werden.

Wann jeweils zu verwenden ist Funktion

• Verwenden Sie std::move, wenn Sie ein Objekt als temporär markieren und zulassen möchten, dass es ungültig wird.
• Verwenden Sie std::forward, wenn Sie übergeben müssen ein Argument von einer Funktionsvorlage zu einer anderen Funktion, wobei sein Wert erhalten bleibt Kategorie.

Beispiel:

Betrachten Sie den folgenden Code:

void overloaded( const int& arg ) { std::cout << "by lvalue\n"; }
void overloaded( int&& arg ) { std::cout << "by rvalue\n"; }

template<typename T>
void forwarding( T&& arg ) {
    std::cout << "via std::forward: ";
    overloaded( std::forward<T>(arg) );
    std::cout << "via std::move: ";
    overloaded( std::move(arg) ); // conceptually this would invalidate arg
    std::cout << "by simple passing: ";
    overloaded( arg );
}

int main() {
    std::cout << "initial caller passes rvalue:\n";
    forwarding( 5 );
    std::cout << "initial caller passes lvalue:\n";
    int x = 5;
    forwarding( x );
}

Ausgabe:

initial caller passes rvalue:
via std::forward: by rvalue
via std::move: by rvalue
by simple passing: by rvalue
initial caller passes lvalue:
via std::forward: by lvalue
via std::move: by lvalue
by simple passing: by lvalue

• Beim Übergeben eines R-Werts (5) behalten sowohl std::forward als auch std::move seinen Status als bei ein R-Wert.
• Bei der Übergabe eines L-Werts (x) behält std::forward seinen L-Wert-Status bei, während std::move versucht, ihn zu verschieben und ihn hypothetisch ungültig zu machen (obwohl der Compiler dies in diesem Beispiel wegoptimiert). ).

Das obige ist der detaillierte Inhalt vonstd::move vs. std::forward: Wann sollte ich beide für eine perfekte Weiterleitung verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!