База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

Декларатор за референция към rvalue (`&&`)

Деклараторът `&&` образува тип референция към rvalue. Изборът на претоварена функция обаче зависи от категорията на израза: името на променлива от тип `T&&` е lvalue, когато се подава като аргумент.

Версия: ISO C++23; implementation support may vary

Синтаксис

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

В T&& ref, ако T е обектен тип, който не е референция, && декларира референция към rvalue. T& е референция към lvalue, а в const T& квалификаторът const се отнася за обекта. Това не е вграденото логическо И a && b, което пропуска десния операнд, ако левият е неистина, нито побитовото И a & b или вземането на адрес с &x. В void f() && това е референтен квалификатор на член-функция. Референциите към rvalue съществуват от C++11; тук са описани правилата на ISO C++23.

Обикновена референция T&& не може да се свърже пряко с lvalue от същия обектен тип T. Тя може да се свърже с prvalue, при което за свързването се материализира временен обект, или с xvalue като std::move(x), което може да обозначава съществуващ обект. Като аргумент на извикване името ref е lvalue дори когато е декларирано като T&&. При претоварванията с const int& и int&& в примера rvalue от тип int избира int&&, а lvalue от тип int или xvalue от тип const int избира const int&.

За обект std::move от <utility> дава xvalue: не премахва const и само по себе си не премества нищо. Task(Task&&) и Task& operator=(Task&&) са типични операции за преместване; във втората декларация Task& е типът на резултата. Операцията може да прехвърли собствеността върху ресурс, например рамката на корутина, но самото свързване на референцията не я прехвърля. При операциите за копиране = delete забранява използването им; при операция за преместване = default изисква реализация според правилата на езика, която все пак може да бъде дефинирана като изтрита.

Локалната декларация T&& ref = T{}; удължава живота на този временен обект до края на живота на референцията. Временен обект, свързан с референтен параметър, живее само до края на пълния израз, съдържащ извикването. Предаването на референцията нататък не удължава живота на обекта повторно. Не връщай референция към локален обект, който се унищожава при излизане от функцията.

В template<class U> void relay(U&& arg) при извеждане на типа U параметърът U&& е препращаща референция. За lvalue от тип T типът U се извежда като T& и свиването на референциите дава T&; за rvalue от тип T резултатът е T&&. При свиване наличието на & дава &; само две && дават &&. Използвай std::forward<U>(arg) от <utility>, за да препратиш аргумента като lvalue или rvalue според извеждането. const U&& не е препращаща референция.

Примери

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

Резултат

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

В извикването `ref` е lvalue, а `std::move(ref)` е xvalue и избира `int&&`. `std::move(frozen)` запазва `const`, затова избира `const int&`. Програмата показва избор на претоварена функция, а не прехвърляне на ресурси.

Свързани уроци

  • C++ · Урок 11 · Напреднало · Версия: 3
  • C++ · Урок 19 · Напреднало · Версия: 3
  • C++ · Урок 41 · Напреднало · Версия: 3
  • C++ · Урок 42 · Напреднало · Версия: 3
  • C++ · Урок 43 · Напреднало · Версия: 3
  • C++ · Урок 45 · Напреднало · Версия: 3

Източници