CKTIS / C++
Declarador de referência a rvalue (`&&`)
O declarador `&&` forma um tipo de referência a rvalue. A resolução de sobrecargas depende, porém, da categoria da expressão: o nome de uma variável declarada `T&&` é um lvalue quando usado como argumento.
Versão: ISO C++23; implementation support may vary
Sintaxe
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 deducedEm T&& ref, se T for um tipo de objeto e não um tipo de referência, && declara uma referência a rvalue. T& é uma referência a lvalue; em const T&, const qualifica o objeto. Não é o E lógico incorporado a && b, que não avalia o operando direito se o esquerdo for falso, nem o E bit a bit a & b, nem a obtenção do endereço &x. Em void f() &&, é um qualificador de referência da função membro. As referências a rvalue existem desde C++11; aqui aplicam-se as regras de ISO C++23.
Uma referência T&& comum não se pode ligar diretamente a um lvalue do mesmo tipo de objeto T. Pode ligar-se a um prvalue, que materializa um objeto temporário para a ligação, ou a um xvalue como std::move(x), que pode designar um objeto existente. Como argumento de uma chamada, o nome ref é um lvalue mesmo quando declarado T&&. Com as sobrecargas const int& e int&& do exemplo, um rvalue de tipo int seleciona int&&; um lvalue de tipo int ou um xvalue de tipo const int seleciona const int&.
Para um objeto, std::move, de <utility>, produz um xvalue: não retira const nem move nada por si só. Task(Task&&) e Task& operator=(Task&&) são operações de movimento típicas; Task& é o tipo de retorno da segunda. A operação pode transferir a propriedade de um recurso, como o quadro de uma corrotina, mas a ligação da referência não a transfere. Nas operações de cópia, = delete proíbe a sua utilização; numa operação de movimento, = default pede a implementação definida pela linguagem, que pode ainda assim ficar eliminada.
A declaração local T&& ref = T{}; prolonga a vida desse temporário até ao fim da vida da referência. Um temporário ligado a um parâmetro de referência vive apenas até ao fim da expressão completa que contém a chamada. Passar a referência adiante não volta a prolongar a vida do objeto. Não devolvas uma referência para um objeto local destruído à saída da função.
Em template<class U> void relay(U&& arg), U&& é uma referência de encaminhamento quando U é deduzido. Para um lvalue de tipo T, U é deduzido como T& e o colapso de referências produz T&; para um rvalue de tipo T, o resultado é T&&. No colapso, a presença de & dá &; só dois && dão &&. Usa std::forward<U>(arg) de <utility> para encaminhar o argumento como lvalue ou rvalue de acordo com a dedução. const U&& não é uma referência de encaminhamento.
Exemplos
#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));
}
Resultado
const int& int&& const int& int&& const int&
Na chamada, `ref` é um lvalue, enquanto `std::move(ref)` é um xvalue e seleciona `int&&`. `std::move(frozen)` mantém `const`, pelo que seleciona `const int&`. O programa demonstra a seleção de sobrecargas, não a transferência de recursos.
Lições relacionadas
- C++ · Lição 11 · Avançado · Versão: 3
- C++ · Lição 19 · Avançado · Versão: 3
- C++ · Lição 41 · Avançado · Versão: 3
- C++ · Lição 42 · Avançado · Versão: 3
- C++ · Lição 43 · Avançado · Versão: 3
- C++ · Lição 45 · Avançado · Versão: 3
Fontes
- Working Draft, Standard for Programming Language C++ (N4950)
- References [dcl.ref]
- Reference initialization [dcl.init.ref]
- Value category [basic.lval]
- Temporary objects [class.temporary]
- Deducing template arguments from a function call [temp.deduct.call]
- Forward/move helpers [forward]
- Ranking implicit conversion sequences [over.ics.rank]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Compound expressions [expr.compound]
- Functions [dcl.fct]