C ++ 11 rvalues ​​e mover semântica confusão (declaração de retorno)

Estou tentando entender as referências rvalue e mover a semântica do C ++ 11.

Qual é a diferença entre esses exemplos e qual deles não fará cópia vetorial?

Primeiro exemplo

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> &&rval_ref = return_vector();

Segundo exemplo

std::vector<int>&& return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

Terceiro exemplo

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

Primeiro exemplo

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> &&rval_ref = return_vector();

O primeiro exemplo retorna um temporário que é capturado por rval_ref. Esse temporário terá sua vida estendida além da rval_refdefinição e você pode usá-lo como se o tivesse captado por valor. Isso é muito semelhante ao seguinte:

const std::vector<int>& rval_ref = return_vector();

exceto que, na minha reescrita, você obviamente não pode usar de rval_refmaneira não-constante.

Segundo exemplo

std::vector<int>&& return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

No segundo exemplo, você criou um erro em tempo de execução. rval_refagora mantém uma referência aos destruídos tmpdentro da função. Com alguma sorte, esse código falharia imediatamente.

Terceiro exemplo

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

Seu terceiro exemplo é aproximadamente equivalente ao seu primeiro. O std::moveon tmpé desnecessário e pode realmente ser uma pessimização de desempenho, pois inibirá a otimização do valor de retorno.

A melhor maneira de codificar o que você está fazendo é:

Melhor prática

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

Ou seja, como você faria em C ++ 03. tmpé implicitamente tratado como um rvalue na declaração de retorno. Ele será retornado via otimização do valor de retorno (sem cópia, sem movimentação) ou se o compilador decidir que não pode executar o RVO, utilizará o construtor de movimentação do vetor para fazer o retorno . Somente se o RVO não for executado, e se o tipo retornado não tiver um construtor de movimentação, o construtor de cópia será usado para o retorno.

Nenhum deles será copiado, mas o segundo se referirá a um vetor destruído. Referências rvalues ​​nomeadas quase nunca existem no código regular. Você escreve exatamente como teria escrito uma cópia em C ++ 03.

std::vector<int> return_vector()
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

Exceto agora, o vetor é movido. O usuário de uma classe não lida com suas referências de valor na grande maioria dos casos.

A resposta simples é que você deve escrever um código para as referências rvalue, como faria com o código de referência regular, e tratá-las mentalmente 99% do tempo. Isso inclui todas as regras antigas sobre o retorno de referências (ou seja, nunca retorne uma referência a uma variável local).

A menos que você esteja escrevendo uma classe de contêiner de modelo que precise tirar proveito do std :: forward e possa escrever uma função genérica que use referências lvalue ou rvalue, isso é mais ou menos verdadeiro.

Uma das grandes vantagens para o construtor de movimento e a atribuição de movimento é que, se você os definir, o compilador poderá usá-los nos casos em que o RVO (otimização do valor de retorno) e o NRVO (otimização do valor de retorno) não serão chamados. Isso é muito grande para devolver objetos caros, como contêineres e strings, pelo valor de forma eficiente dos métodos.

Agora, onde as coisas ficam interessantes com as referências rvalue, é que você também pode usá-las como argumentos para funções normais. Isso permite que você escreva contêineres com sobrecargas para referência const (const foo & other) e rvalue reference (foo && other). Mesmo que o argumento seja muito difícil de passar com uma simples chamada de construtor, ele ainda pode ser feito:

std::vector vec;
for(int x=0; x<10; ++x)
{
    // automatically uses rvalue reference constructor if available
    // because MyCheapType is an unamed temporary variable
    vec.push_back(MyCheapType(0.f));
}


std::vector vec;
for(int x=0; x<10; ++x)
{
    MyExpensiveType temp(1.0, 3.0);
    temp.initSomeOtherFields(malloc(5000));

    // old way, passed via const reference, expensive copy
    vec.push_back(temp);

    // new way, passed via rvalue reference, cheap move
    // just don't use temp again,  not difficult in a loop like this though . . .
    vec.push_back(std::move(temp));
}

Os contêineres STL foram atualizados para sobrecargas de movimentação para quase qualquer coisa (chave e valores de hash, inserção de vetor etc.) e é onde você os vê mais.

Você também pode usá-los para funções normais e, se você fornecer apenas um argumento de referência rvalue, poderá forçar o chamador a criar o objeto e permitir que a função faça a movimentação. Isso é mais um exemplo do que um uso realmente bom, mas, na minha biblioteca de renderização, atribui uma string a todos os recursos carregados, para que seja mais fácil ver o que cada objeto representa no depurador. A interface é algo como isto:

TextureHandle CreateTexture(int width, int height, ETextureFormat fmt, string&& friendlyName)
{
    std::unique_ptr<TextureObject> tex = D3DCreateTexture(width, height, fmt);
    tex->friendlyName = std::move(friendlyName);
    return tex;
}

É uma forma de "abstração com vazamento", mas me permite aproveitar o fato de que eu já tinha criado a string na maior parte do tempo e evitar fazer mais uma cópia dela. Este não é exatamente um código de alto desempenho, mas é um bom exemplo das possibilidades de as pessoas entenderem esse recurso. Esse código realmente exige que a variável seja temporária para a chamada ou std :: move invocada:

// move from temporary
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, string("Checkerboard"));

ou

// explicit move (not going to use the variable 'str' after the create call)
string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, std::move(str));

ou

// explicitly make a copy and pass the temporary of the copy down
// since we need to use str again for some reason
string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, string(str));

mas isso não será compilado!

string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, str);

Não é uma resposta em si , mas uma orientação. Na maioria das vezes, não há muito sentido em declarar T&&variável local (como você fez com std::vector<int>&& rval_ref). Você ainda precisará std::move()deles para usar nos foo(T&&)métodos de tipo. Também existe o problema que já foi mencionado: quando você tenta retornar tal rval_reffunção, você obtém o fiasco de referência padrão ao fiasco temporário destruído.

Na maioria das vezes, eu seguia o seguinte padrão:

// Declarations
A a(B&&, C&&);
B b();
C c();

auto ret = a(b(), c());

Você não mantém nenhuma referência a objetos temporários retornados, assim evita o erro do programador (inexperiente) que deseja usar um objeto movido.

auto bRet = b();
auto cRet = c();
auto aRet = a(std::move(b), std::move(c));

// Either these just fail (assert/exception), or you won't get 
// your expected results due to their clean state.
bRet.foo();
cRet.bar();

Obviamente, existem casos (embora bastante raros) em que uma função realmente retorna um T&&que é uma referência a um objeto não temporário que você pode mover para o seu objeto.

Com relação ao RVO: esses mecanismos geralmente funcionam e o compilador pode evitar a cópia, mas nos casos em que o caminho de retorno não é óbvio (exceções, ifcondicionais determinando o objeto nomeado que você retornará e provavelmente outros) rrefs são seus salvadores (mesmo que potencialmente mais caro).

Nenhum deles fará cópias extras. Mesmo que o RVO não seja usado, o novo padrão diz que é preferível copiar a construção de movimento ao fazer retornos, acredito.

Eu acredito que seu segundo exemplo causa comportamento indefinido porque você está retornando uma referência a uma variável local.

Como já mencionado nos comentários da primeira resposta, o return std::move(...);construto pode fazer a diferença em casos que não sejam o retorno de variáveis ​​locais. Aqui está um exemplo executável que documenta o que acontece quando você retorna um objeto de membro com e sem std::move():

#include <iostream>
#include <utility>

struct A {
  A() = default;
  A(const A&) { std::cout << "A copied\n"; }
  A(A&&) { std::cout << "A moved\n"; }
};

class B {
  A a;
 public:
  operator A() const & { std::cout << "B C-value: "; return a; }
  operator A() & { std::cout << "B L-value: "; return a; }
  operator A() && { std::cout << "B R-value: "; return a; }
};

class C {
  A a;
 public:
  operator A() const & { std::cout << "C C-value: "; return std::move(a); }
  operator A() & { std::cout << "C L-value: "; return std::move(a); }
  operator A() && { std::cout << "C R-value: "; return std::move(a); }
};

int main() {
  // Non-constant L-values
  B b;
  C c;
  A{b};    // B L-value: A copied
  A{c};    // C L-value: A moved

  // R-values
  A{B{}};  // B R-value: A copied
  A{C{}};  // C R-value: A moved

  // Constant L-values
  const B bc;
  const C cc;
  A{bc};   // B C-value: A copied
  A{cc};   // C C-value: A copied

  return 0;
}

Presumivelmente, return std::move(some_member);só faz sentido se você realmente deseja mover um membro da classe específico, por exemplo, em um caso em que class Crepresente objetos adaptadores de vida curta com o único objetivo de criar instâncias de struct A.

Observe como struct Asempre fica copiado fora de class B, mesmo quando o class Bobjeto é um valor-R. Isso ocorre porque o compilador não tem como dizer que essa class Binstância struct Anão será mais usada. Em class C, o compilador tem esta informação a partir std::move(), que é por isso que struct Ase moveu , a menos que a instância do class Cé constante.