C++

Αναφορές: Lvalue, Rvalue & Pitfalls

Εξερευνήστε τις αναφορές lvalue και rvalue, κατανοήστε τις κατηγορίες τιμών C++, μάθετε κανόνες σύμπτυξης αναφοράς και αναφορές προώθησης και αποφύγετε τα κρεμαστά σφάλματα αναφοράς.

Αναφορές Lvalue

Μια lvalue αναφορά (T&) είναι ένα ψευδώνυμο — ένα άλλο όνομα για ένα υπάρχον αντικείμενο. Σε αντίθεση με τους δείκτες, οι αναφορές πρέπει να αρχικοποιηθούν, δεν μπορούν να είναι μηδενικές και δεν μπορούν να επανατοποθετηθούν για να αναφέρονται σε διαφορετικό αντικείμενο.

Οι αναφορές Lvalue συνδέονται με lvalues — εκφράσεις που έχουν ταυτότητα (μπορείτε να πάρετε τη διεύθυνσή τους). Οι μεταβλητές, τα στοιχεία πίνακα και οι δείκτες που δεν αναφέρονται είναι όλα lvalues. Μια αναφορά non-const lvalue (int&) δεν μπορεί να συνδεθεί με μια προσωρινή (rvalue) επειδή η τροποποίηση μιας προσωρινής είναι σχεδόν πάντα ένα σφάλμα.

Βασικά στοιχεία αναφοράς Lvalue

Οι αναφορές Lvalue είναι το όριο εργασίας του C++ — χρησιμοποιούνται για παραπομπή, υπερφόρτωση χειριστή και αποφυγή αντιγράφων.

lvalue_refs.cpp
#include <iostream>
#include <string>

void append_greeting(std::string& s) {
    s += ", welcome!";  // modifies the caller's string
}

int main() {
    int x = 10;
    int& ref = x;      // ref is an alias for x
    ref = 20;
    std::cout << x << '\n';  // 20 — x was modified through ref

    // const reference can bind to a temporary (rvalue)
    const std::string& greeting = std::string("Hello");
    // The temporary's lifetime is extended to match greeting's scope
    std::cout << greeting << '\n';  // "Hello"

    // Non-const lvalue reference CANNOT bind to rvalue:
    // std::string& bad = std::string("oops");  // COMPILER ERROR

    std::string name = "Alice";
    append_greeting(name);
    std::cout << name << '\n';  // "Alice, welcome!"
}

Κατηγορίες αξίας στο C++

Το C++ έχει μια ακριβή ταξινόμηση κατηγοριών τιμών έκφρασης. Η κατανόησή τους είναι απαραίτητη για τη σημασιολογία της κίνησης και την τέλεια προώθηση:

- lvalue — έχει ταυτότητα, δεν μπορεί να μετακινηθεί από σιωπηρά. Παραδείγματα: μεταβλητές,*ptr,arr[i], κυριολεκτικά συμβολοσειρών.
- prvalue (καθαρή rvalue) — δεν έχει ταυτότητα, μπορεί να μετακινηθεί από. Παραδείγματα:42,x + y,std::string("temp"), συνάρτηση που επιστρέφει κατά τιμή.
- xvalue (τιμή που λήγει) — έχει ταυτότητα ΚΑΙ μπορεί να μετακινηθεί από. Παραδείγματα:std::move(x),static_cast(x), μέλος μιας rvalue.
- glvalue (γενικευμένη lvalue) — lvalue ή xvalue (έχει ταυτότητα).
- rvalue — prvalue ή xvalue (μπορεί να μετακινηθεί από).

Η βασική εικόνα: μια μεταβλητή αναφοράς rvalue είναι η ίδια lvalue — έχει ένα όνομα και μια διεύθυνση. Αυτή είναι η πηγή πολλής σύγχυσης και είναι ακριβώς ο λόγος που υπάρχει τοstd::forward.

Αναφορές Rvalue (T&&)

Οι αναφορές Rvalue συνδέονται με rvalues ​​(προσωρινά και αντικείμεναstd::move'd). Αποτελούν το θεμέλιο της σημασιολογίας της κίνησης — σας επιτρέπουν να εντοπίσετε πότε ένα αντικείμενο πρόκειται να καταστραφεί και να κλέψετε τους πόρους του.

rvalue_refs.cpp
#include <iostream>
#include <string>
#include <utility>  // std::move

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

void process(std::string&& s) {
    std::cout << "rvalue: " << s << '\n';
    // s is an lvalue inside this function (it has a name!)
    // To move from s, you'd need std::move(s)
}

int main() {
    std::string a = "hello";
    process(a);               // calls lvalue overload
    process(std::string("world"));  // calls rvalue overload
    process(std::move(a));    // calls rvalue overload — a is now moved-from

    // IMPORTANT: a is in a valid but unspecified state
    // Only safe operations: assign to it, destroy it
    std::cout << "a after move: '" << a << "'\n";  // likely empty
}

Αναφορά Σύμπτυξη & Προώθηση Αναφορών

When references combine in templates, reference collapsing rules apply:

-T& &collapses toT&
-T& &&collapses toT&
-T&& &collapses toT&
-T&& &&collapses toT&&

The rule is simple: if either reference is an lvalue reference, the result is an lvalue reference. Only&& &&gives&&.

A forwarding reference (also called universal reference) isT&&whereTis a deduced template parameter. It can bind to both lvalues and rvalues.auto&&is also a forwarding reference. Butstd::vector&&is NOT —Tis already known.const T&&is also not a forwarding reference.

Παγίδα

Μια κρεμασμένη αναφορά αναφέρεται σε ένα κατεστραμμένο αντικείμενο. Σε αντίθεση με τους δείκτες που κρέμονται, δεν υπάρχει έλεγχοςnullptr— ο κωδικός θα χρησιμοποιήσει αθόρυβα δεδομένα σκουπιδιών ή θα διακοπεί.

Συνήθεις αιτίες:

- Επιστροφή αναφοράς σε τοπική μεταβλητή — η μεταβλητή καταστρέφεται όταν επιστρέφει η συνάρτηση.
- Λήψη με αναφορά σε λάμδα που υπερβεί τη μεταβλητή αναφοράς.
- const auto&σε μια προσωρινή μέσα σε μια έκφραση — Τοconst auto& val = get_map()["key"]είναι κρέμεται εάν τοget_map()επιστρέφει κατά τιμή, επειδή ο προσωρινός χάρτης καταστρέφεται στο ερωτηματικό.
- Βασισμένο σε εύρος για βρόχο σε προσωρινό — Τοfor (auto& x : get_vector())είναι εντάξει (προσωρινή διάρκεια ζωής για τον βρόχο), αλλά τοfor (auto& x : get_wrapper().get_vector())μπορεί να κρέμεται αν καταστραφεί το περιτύλιγμα.

Lifetime Extension with const T&

Μια αναφορά lvalueconstμπορεί να παρατείνει τη διάρκεια ζωής μιας προσωρινής, αλλά μόνο όταν άμεσα δεσμεύεται. Αυτό ΔΕΝ λειτουργεί μέσω κλήσεων λειτουργιών ή αλυσίδων πρόσβασης μελών.

lifetime_extension.cpp
#include <iostream>
#include <string>

std::string make_greeting() { return "Hello, World!"; }

const std::string& identity(const std::string& s) { return s; }

int main() {
    // SAFE: const ref directly bound to temporary
    const std::string& good = make_greeting();
    std::cout << good << '\n';  // OK — lifetime extended

    // DANGEROUS: lifetime extension does NOT propagate through functions
    const std::string& bad = identity(make_greeting());
    // bad is DANGLING — the temporary was destroyed after identity() returned
    // std::cout << bad << '\n';  // UNDEFINED BEHAVIOR

    // SAFE: just use a value
    std::string safe = make_greeting();  // move or copy-elision
    std::cout << safe << '\n';  // always safe
}
Βασικά συμπεράσματα
  • Lvalue references (T&) are aliases — must be initialized, cannot be null or re-seated
  • const T&can bind to temporaries and extends their lifetime (but only when directly bound)
  • Rvalue references (T&&) bind to temporaries and enable move semantics
  • A named rvalue reference is itself an lvalue — this is critical to understand
  • Reference collapsing: any&in the chain makes the result&
  • Forwarding references (T&&with deducedT) bind to both lvalues and rvalues

Κουίζ — Δοκιμάστε τις γνώσεις σας

(15 XP)

1. Given`void f(std::string&& s)`, what is the value category of`s`inside`f`?

2. Which reference collapsing rule is correct?

3. When does`const T&`lifetime extension work for temporaries?

Προηγούμενο
Δείκτες: Διευθύνσεις, Αποαναφορά και Αριθμητική
Επόμενο
Δυναμική μνήμη: νέα, διαγραφή και οι κίνδυνοι τους