O que std::move() faz com lvalues?

std::move() é uma ferramenta poderosa em C para facilitar encaminhamento perfeito. No entanto, a sua implementação pode levantar algumas sobrancelhas à primeira vista. Para esclarecer como std::move() consegue isso, vamos nos aprofundar nos meandros de sua implementação.

Compreendendo a função 'Move'

Começaremos com a versão simplificada do modelo de função 'move':

template 
typename remove_reference::type&& move(T&& arg)
{ return static_cast::type&&>(arg); }

Caso 1: Passando um Rvalue

Quando std::move() é chamado com um rvalue (um objeto temporário ou uma expressão que é avaliada como um rvalue) , o modelo de movimentação é instanciado da seguinte forma:

// move with [T = Object]:
remove_reference

Como remove_reference

Object&& move(Object&& arg) { return static_cast

Como antecipado, a função simplesmente lança seu argumento rvalue para uma referência rvalue.

Caso 2: Passando um Lvalue

Agora, o interessante O caso surge quando std::move() é invocado com um lvalue (uma variável nomeada ou uma expressão que é avaliada como um lvalue).

Object a; // a is lvalue
Object b = std::move(a);

Desta vez, o modelo de movimentação é instanciado para:

// move with [T = Object&]
remove_reference

Novamente, remove_reference

Object&& move(Object& && arg) { return static_cast

À primeira vista, isso parece contra-intuitivo, já que passamos um lvalue. No entanto, C 11 introduz o conceito de reference colapso, que modifica a interpretação da sintaxe de referência:

• Object & & = Object &
• Object & & && = Objeto &
• Objeto & && & = Objeto &
• Objeto & && & && = Objeto & &&

Sob essas regras, Object& && efetivamente se comporta como Object&, uma referência lvalue comum que pode ser vinculada a lvalues.

Portanto, a forma final da função se torna:

Object&& move(Object& arg) { return static_cast

Em essência, std::move() converte o argumento lvalue em uma referência rvalue, permitindo o encaminhamento perfeito independentemente do tipo de entrada.