Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Deklarator referencji do r-wartości (`&&`)

Deklarator `&&` tworzy typ referencji do r-wartości. O wyborze przeciążenia decyduje jednak kategoria wyrażenia: sama nazwa zmiennej typu `T&&` jest l-wartością.

Wersja: ISO C++23; implementation support may vary

Składnia

T&& ref = expr;               // local reference; requires a suitable initializer
void consume(T&& arg);        // reference parameter
T&& access();                 // reference return type; does not extend lifetime
using R = T&&;                // reference type alias; collapsing can apply
template<class U> void relay(U&& arg);  // forwarding reference when U is deduced

W T&& ref, dla typu obiektowego T, który nie jest referencją, && deklaruje referencję do r-wartości. T& to referencja do l-wartości, a w const T& kwalifikator const dotyczy obiektu. To nie wbudowane logiczne a && b, które pomija prawy operand, gdy lewy jest fałszywy, ani bitowe a & b, ani pobranie adresu &x. W void f() && token jest kwalifikatorem referencyjnym funkcji składowej, a nie deklaratorem referencji. Referencje do r-wartości istnieją od C++11; opis dotyczy ISO C++23.

Dla tego samego typu obiektowego T zwykła referencja T&& nie wiąże się bezpośrednio z l-wartością typu T. Może się związać z pr-wartością, która przy wiązaniu materializuje obiekt tymczasowy, albo z x-wartością, np. std::move(x), która może wskazywać istniejący obiekt. W wywołaniu sama nazwa ref jest l-wartością, nawet jeśli zadeklarowano ją jako T&&. Dla pokazanej w przykładzie pary przeciążeń const int& i int&& r-wartość typu int wybiera int&&, a l-wartość typu int lub x-wartość typu const int wybiera const int&.

std::move z <utility> dla obiektu daje x-wartość: nie usuwa const i sam niczego nie przenosi. Task(Task&&) i Task& operator=(Task&&) to typowe deklaracje operacji przenoszenia; Task& w drugiej jest typem wyniku. Operacja może przekazać własność zasobu, np. ramki korutyny, ale samo wiązanie referencji jej nie przekazuje. Dla operacji kopiowania = delete zabrania ich użycia; = default przy operacji przenoszenia prosi kompilator o definicję zgodną z regułami języka, która może być usunięta.

Lokalne T&& ref = T{}; przedłuża życie tego obiektu tymczasowego do końca życia referencji. Obiekt tymczasowy związany z parametrem referencyjnym żyje tylko do końca pełnego wyrażenia zawierającego wywołanie. Przekazanie referencji dalej nie przedłuża życia obiektu ponownie. Nie zwracaj referencji do lokalnego obiektu, który zostanie zniszczony przy wyjściu z funkcji.

W template<class U> void relay(U&& arg) dedukowane U&& jest referencją przekazującą. Dla l-wartości typu T parametr U jest dedukowany jako T&, a złożenie referencji daje T&; dla r-wartości typu T wynikiem jest T&&. Przy składaniu referencji obecność & daje &, a tylko dwa && dają &&. Użyj std::forward<U>(arg) z <utility>, żeby przekazać argument dalej jako l-wartość lub r-wartość zgodnie z dedukcją. const U&& nie jest referencją przekazującą.

Przykłady

#include <iostream>
#include <utility>

void probe(const int&) { std::cout << "const int&\n"; }
void probe(int&&)      { std::cout << "int&&\n"; }

int main() {
    int value = 1;
    int&& ref = 2;
    const int frozen = 3;

    probe(value);
    probe(7);
    probe(ref);
    probe(std::move(ref));
    probe(std::move(frozen));
}

Wynik

const int&
int&&
const int&
int&&
const int&

`ref` w wywołaniu jest l-wartością, a `std::move(ref)` jest x-wartością i wybiera `int&&`. `std::move(frozen)` zachowuje `const`, więc wybiera `const int&`. Program pokazuje wybór przeciążenia, a nie przenoszenie zasobów.

Powiązane lekcje

  • C++ · Lekcja 11 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 19 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 41 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 42 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 43 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 45 · Zaawansowany · Wersja: 3

Źródła