Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Deklarátor referencie na rvalue (`&&`)

Deklarátor `&&` vytvára typ referencie na rvalue. Pri výbere preťaženia však rozhoduje kategória výrazu: názov premennej deklarovanej ako `T&&` je pri použití ako argument lvalue.

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

Syntax

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

V T&& ref, kde T je objektový typ, ktorý nie je referenciou, deklaruje && referenciu na rvalue. T& je referencia na lvalue; v const T& kvalifikuje const objekt. Nejde o vstavané logické a && b, ktoré nevyhodnotí pravý operand, ak je ľavý nepravdivý, ani o bitové a & b či získanie adresy &x. V void f() && ide o referenčný kvalifikátor členskej funkcie. Referencie na rvalue existujú od C++11; tu platia pravidlá ISO C++23.

Bežnú referenciu T&& nemožno priamo naviazať na lvalue rovnakého objektového typu T. Možno ju naviazať na prvalue, pri ktorom sa na naviazanie materializuje dočasný objekt, alebo na xvalue ako std::move(x), ktoré môže označovať existujúci objekt. Ako argument volania je názov ref lvalue, aj keď je deklarovaný ako T&&. Pri preťaženiach const int& a int&& v príklade vyberie rvalue typu int variant int&&; lvalue typu int alebo xvalue typu const int vyberie const int&.

std::move z <utility> vytvorí pre objekt xvalue: neodstráni const a samo nič nepresunie. Task(Task&&) a Task& operator=(Task&&) sú typické operácie presunu; v druhej deklarácii je Task& návratový typ. Operácia môže previesť vlastníctvo prostriedku, napríklad rámca korutiny, ale samotné naviazanie referencie ho neprevádza. Pri operáciách kopírovania = delete zakazuje ich použitie; = default pri operácii presunu žiada implementáciu podľa pravidiel jazyka, ktorá napriek tomu môže byť definovaná ako odstránená.

Lokálna deklarácia T&& ref = T{}; predlžuje životnosť tohto dočasného objektu na dobu životnosti referencie. Dočasný objekt naviazaný na referenčný parameter žije len do konca úplného výrazu obsahujúceho volanie. Odovzdanie referencie ďalej životnosť objektu znova nepredĺži. Nevracajte referenciu na lokálny objekt, ktorý sa pri opustení funkcie zničí.

V template<class U> void relay(U&& arg) je U&& pri dedukcii U odovzdávacia referencia. Pre lvalue typu T sa U odvodí ako T& a zložením referencií vznikne T&; pre rvalue typu T vznikne T&&. Pri skladaní každý výskyt & znamená výsledok &; iba dve && dajú &&. Použite std::forward<U>(arg) z <utility>, aby sa argument odovzdal ako lvalue alebo rvalue podľa dedukcie. const U&& nie je odovzdávacia referencia.

Príklady

#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));
}

Výsledok

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

Pri volaní je `ref` lvalue, kým `std::move(ref)` je xvalue a vyberie `int&&`. `std::move(frozen)` zachová `const`, a preto vyberie `const int&`. Program ukazuje výber preťaženia, nie prevod prostriedkov.

Súvisiace lekcie

  • C++ · Lekcia 11 · Pokročilá · Verzia: 3
  • C++ · Lekcia 19 · Pokročilá · Verzia: 3
  • C++ · Lekcia 41 · Pokročilá · Verzia: 3
  • C++ · Lekcia 42 · Pokročilá · Verzia: 3
  • C++ · Lekcia 43 · Pokročilá · Verzia: 3
  • C++ · Lekcia 45 · Pokročilá · Verzia: 3

Zdroje