C++ Academy · Lektion

Rvalue-Referenzen und die &&-Syntax

Binden Sie mit Rvalue-Referenzen an temporäre Objekte, um Ressourcen effizient zu übertragen.

Lektion 2 von 413 Schritte

Rvalue-Referenzen und die &&-Syntax ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Die Syntax von &&

Eine rvalue-Referenz wird mit T&& deklariert. Sie bindet nur an rvalues – temporäre Objekte, die kurz vor ihrer Zerstörung stehen.

int&& ref = 42;          // OK: binds to literal
int x = 10;
// int&& bad = x;        // ERROR: x is an lvalue

Warum gibt es rvalue-Referenzen?

Sie ermöglichen Ihnen, Funktionen zu schreiben, die wissen, dass das Argument gleich zerstört wird. Sie können seine Ressourcen übernehmen, ohne eine Kopie anzufertigen.

Funktionsüberladung nach Referenztyp

Sie können eine Funktion für T& und T&& überladen. Der Compiler wählt anhand der Wertkategorie des Arguments die passende Variante aus.

void process(std::string& s) { std::cout << "lvalue\n"; }
void process(std::string&& s) { std::cout << "rvalue\n"; }

std::string s = "hi";
process(s);            // lvalue
process("temp");       // rvalue
process(std::move(s)); // rvalue

Benannte rvalue-Referenzen werden zu lvalues

Sobald Sie einer rvalue-Referenz einen Namen geben, ist dieser Name selbst ein lvalue – seine Identität ist damit festgelegt. Verwenden Sie std::move, um wieder einen rvalue zu erhalten.

void f(std::string&& s) {
    // inside f, the parameter s is an lvalue
    g(s);              // passes s by lvalue
    h(std::move(s));   // passes s as an rvalue
}

std::move ist eine Typumwandlung

std::move(x) verschiebt selbst nichts – es handelt sich um eine Typumwandlung, die x als rvalue-Referenz zurückgibt. Das eigentliche Verschieben findet im empfangenden Konstruktor statt.

// equivalent to
static_cast<std::string&&>(s)

Warum es Move heißt

Der Name beschreibt die typische Verwendung – die Übergabe eines Objekts, dessen Inhalt Sie übernehmen möchten –, aber von sich aus überträgt er nichts.

Universal References (Forwarding-Referenzen)

Wenn T&& in einem Template mit hergeleitetem T vorkommt, handelt es sich um eine Forwarding-Referenz – sie bindet sowohl an lvalues als auch an rvalues und bewahrt deren Kategorie.

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));
}

Referenzzusammenführung

Wenn Referenzen über Templates hinweg verschachtelt werden, führt die Sprache sie zusammen:

T& & → T&
T& && → T&
T&& & → T&
T&& && → T&&

Wann Sie Move nicht verwenden sollten

Bei trivial kopierbaren Typen (int, double, pointer) ist Move dasselbe wie Copy. Der Aufruf von std::move bringt keinen Vorteil und kann Leserinnen und Leser verwirren.

Move ohne eigene Ressourcen

Bei Typen ohne Heap-Ressourcen ist der Move-Konstruktor identisch mit dem Copy-Konstruktor. Move ist nur für Typen vorteilhaft, die dynamischen Speicher besitzen.

Häufiger Fallstrick: Verschieben von const

std::move auf einem const-Objekt ist wirkungslos – der Move-Konstruktor kann für ein const-Objekt nicht aufgerufen werden, da er die Quelle ändern müsste.

Schnelltest

Was bewirkt std::move(x) tatsächlich?

Beantworte es in der interaktiven Lektion

Zusammenfassung

T&& bindet an rvalues. Benannte rvalue-Referenzen werden zu lvalues – verwenden Sie std::move, um wieder einen rvalue zu erhalten. T&& in einem Template ist eine Forwarding-Referenz. std::move ist eine Typumwandlung; es führt das Verschieben nicht selbst aus.

Kostenlos starten

Lerne C++ mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 51
Lektionen: 203

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Rvalue-Referenzen und die &&-Syntax“ kostenlos?

Ja — der vollständige Text von „Rvalue-Referenzen und die &&-Syntax“ 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 „Rvalue-Referenzen und die &&-Syntax“?

Binden Sie mit Rvalue-Referenzen an temporäre Objekte, um Ressourcen effizient zu übertragen. 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 2 von 4.

Wie lange dauert die Lektion „Rvalue-Referenzen und die &&-Syntax“?

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