C++ Academy · Lektion

std::move und std::forward

Wandeln Sie mit std::move Lvalues in Rvalues um und bewahren Sie mit std::forward die Wertkategorie.

std::move und std::forward ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Zwei Verwandte, unterschiedliche Aufgaben

std::move und std::forward sind beide Typumwandlungen zur Compile-Zeit. Sie sehen ähnlich aus, lösen aber unterschiedliche Probleme.

std::move: Immer in einen rvalue umwandeln

std::move(x) wandelt x bedingungslos in eine rvalue-Referenz um. Die empfangende Funktion kann dann seine Ressourcen übernehmen.

std::string s = "Hello";
std::string t = std::move(s);   // move-constructs t from s
// s is now in a valid-but-unspecified state

Wann Sie move verwenden sollten

Verwenden Sie std::move in:

Move-Konstruktoren und Move-Zuweisungsoperatoren
Bei der Rückgabe einer lokalen Variable, wenn Sie ein Verschieben erzwingen möchten (selten erforderlich – RVO greift normalerweise)
Beim Übergeben einer lokalen Variable, die Sie nicht mehr benötigen, an eine Sink-Funktion

Implementierung von std::move

Es ist lediglich ein als static_cast getarnter Ausdruck:

template <typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

std::forward: Kategorie beibehalten

In einem Template, das eine Forwarding-Referenz (T&&) verwendet, wandelt std::forward<T>(x) x zurück in seine ursprüngliche Kategorie (lvalue oder rvalue) um. Es wird für Perfect Forwarding verwendet.

template <typename T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));  // forwards as lvalue or rvalue depending on T
}

Warum Forwarding erforderlich ist

Innerhalb des Templates hat der Parameter einen Namen – dadurch ist er ein lvalue, selbst wenn der Aufrufer einen rvalue übergeben hat. std::forward stellt die ursprüngliche Kategorie wieder her.

Ohne std::forward

Ohne forward würde jedes Argument innerhalb des Wrappers als lvalue übergeben und damit jede Move-Semantik außer Kraft gesetzt, die der Aufrufer beabsichtigt hat.

template <typename T>
void wrapper(T&& arg) {
    target(arg);    // always lvalue — wrong
}

Den Template-Parameter für forward immer angeben

std::forward<T> erfordert das explizite Template-Argument. Ohne dieses wäre das Verhalten falsch.

Beispiel für Perfect Forwarding

Eine Factory-Funktion, die Konstruktorargumente weiterleitet, bewahrt zur Effizienzsteigerung die Unterscheidung zwischen rvalue und lvalue.

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Nur einmal verschieben

Aus jedem Objekt sollte höchstens einmal verschoben werden. Nach dem Verschieben befindet es sich in einem gültigen, aber nicht näher bestimmten Zustand – normalerweise weisen Sie ihm erneut einen Wert zu oder zerstören es. Die Verwendung eines verschobenen Objekts ohne vorherige Neuzuweisung kann subtile Fehler verursachen.

Faustregeln

Ein einfaches mentales Modell:

Sie haben einen konkreten Typ und möchten ihn verschieben → std::move
Sie haben einen Template-Parameter und möchten die Kategorie beibehalten → std::forward<T>

Schnelltest

Wie leiten Sie innerhalb einer Template-Funktion mit dem Parameter T&& arg arg weiter und bewahren dabei seine lvalue-/rvalue-Kategorie?

Zusammenfassung

std::move wandelt bedingungslos in einen rvalue um – verwenden Sie es bei konkreten Objekten, deren Ressourcen Sie übernehmen möchten. std::forward<T> bewahrt die Wertkategorie innerhalb generischer Templates – verwenden Sie es für Perfect Forwarding.

Häufig gestellte Fragen

Ist die Lektion „std::move und std::forward“ kostenlos?

Ja — der vollständige Text von „std::move und std::forward“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „std::move und std::forward“?

Wandeln Sie mit std::move Lvalues in Rvalues um und bewahren Sie mit std::forward die Wertkategorie. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „std::move und std::forward“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy