Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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 deduced

Em 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