O que é std::move(), e quando deve ser usado?

Você pode usar o move quando precisa de "transferir" o conteúdo de um objecto noutro lugar, sem fazer uma cópia (por exemplo, o conteúdo não é duplicado, por isso pode ser usado em alguns objectos não copiáveis, como um unique_ptr). Também é possível para um objeto tomar o conteúdo de um objeto temporário sem fazer uma cópia (e economizar muito tempo), com std::mover.

Http://thbecker.net/articles/rvalue_references/section_01.html

Desculpa se a minha resposta está a chegar demasiado tarde, mas também estava à procura de um bom link para a DST::move, e encontrei os links acima um pouco "austeros".

Isso colocou a ênfase na referência do valor r, em que contexto você deve usá-los, e eu acho que é mais detalhado, é por isso que eu queria compartilhar este link aqui.

1. "O que é?"

Embora std::move() seja tecnicamente uma função-eu diria não é realmente {[15] } Uma função . É uma espécie de conversor entre formas que o compilador considera o valor de uma expressão.

2. "O que faz?"

template <class T>
swap(T& a, T& b) {
    T tmp(a);   // we now have two copies of a
    a = b;      // we now have two copies of b (+ discarded a copy of a)
    b = tmp;    // we now have two copies of tmp (+ discarded a copy of b)
}

template <class T>
swap(T& a, T& b) {
    T tmp(std::move(a));
    a = std::move(b);   
    b = std::move(tmp);
}

Q: o que é std::move?

A: std::move() é uma função da Biblioteca-Padrão C++ para o vazamento para uma referência rvalue.

Simplista {[6] } é equivalente a:

static_cast<T&&>(t);

Um rvalue é um temporário que não persiste para além da expressão que o define, como um resultado de função intermediária que nunca é armazenado numa variável.

int a = 3; // 3 is a rvalue, does not exist after expression is evaluated
int b = a; // a is a lvalue, keeps existing after expression is evaluated

Uma implementação para std:: move() é dada em N2027: "A Brief Introduction to Rvalue References" as segue:

template <class T>
typename remove_reference<T>::type&&
std::move(T&& a)
{
    return a;
}

Como pode ver, std::move devolve T&& independentemente de ser chamado com um valor (T), Tipo de Referência (T&) ou referência rvalue (T&&).

Q: O que faz?

foo(3 * 5); // obviously, you are calling foo with a temporary (rvalue)

int a = 3 * 5;
foo(a);     // how to tell the compiler to treat `a` as an rvalue?
foo(std::move(a)); // will call `foo(int&& a)` rather than `foo(int a)` or `foo(int& a)`

O que faz Não faz:

• Faça uma cópia do argumento
• liga para o construtor de cópias
• muda o objecto do argumento

Q: Quando Deve ser utilizado?

A: deverá usar std::move Se quiser chamar as funções que suportam a semântica do movimento com um argumento que não é um valor R (expressão temporária).

• O que são movimentos semânticos? A semântica do movimento em contraste com a semântica da cópia é uma técnica de programação na qual o os membros de um objeto são inicializados por 'assumir' em vez de copiar os membros de outro objeto. Tal "tomada a cargo" faz apenas sentido com ponteiros e pegas de recursos, que podem ser transferidos a baixo custo copiando o ponteiro ou punho inteiro em vez dos dados subjacentes.

• Que tipo de classes e objetos suportam mover semântica? Cabe a você como um desenvolvedor implementar a semântica de movimento em suas próprias classes, se estes beneficiariam de transferir seus membros em vez disso de Os copiar. Uma vez que você implementa a semântica do movimento, você vai se beneficiar diretamente do trabalho de muitos programadores de bibliotecas que adicionaram suporte para lidar com as aulas com a semântica do movimento de forma eficiente.

• Porque é que o compilador não consegue descobrir sozinho? O compilador não pode simplesmente chamar outra sobrecarga de uma função a menos que você o diga. Você deve ajudar o compilador a escolher se a versão regular ou mover da função deve ser chamada.

• Em que situações Quero dizer ao compilador que deve tratar uma variável como um rvalue? Isso provavelmente acontecerá em funções de template ou biblioteca, onde você sabe que um resultado intermediário pode ser salvo.

Std::mover-se por si só não faz muito. Eu pensei que ele chamou o construtor movido para um objeto, mas ele realmente apenas executa um molde tipo (lançando uma variável lvalue para um rvalue de modo que a referida variável pode ser passada como um argumento para um construtor de movimento ou operador de atribuição).

So std:: move is just used as a precursor to using move semantics. A semântica do movimento é essencialmente uma forma eficiente de lidar com objetos temporários.

Considerar Objecto A = B + C + D + E + F;

Por exemplo

Object Object::operator+ (const Object& rhs) {
    Object temp (*this);
    // logic for adding
    return temp;
}

A criação do objecto temporário nesta função é inútil-estes objectos temporários serão apagados no fim da linha à medida que saem do âmbito.

 Object& Object::operator+ (Object&& rhs) {
     // logic to modify rhs directly
     return rhs;
 }

What is it? e What does it do? foi explicado acima.

class ResHeavy{ //  ResHeavy means heavy resource
    public:
        ResHeavy(int len=10):_upInt(new int[len]),_len(len){
            cout<<"default ctor"<<endl;
        }

        ResHeavy(const ResHeavy& rhs):_upInt(new int[rhs._len]),_len(rhs._len){
            cout<<"copy ctor"<<endl;
        }

        ResHeavy& operator=(const ResHeavy& rhs){
            _upInt.reset(new int[rhs._len]);
            _len = rhs._len;
            cout<<"operator= ctor"<<endl;
        }

        ResHeavy(ResHeavy&& rhs){
            _upInt = std::move(rhs._upInt);
            _len = rhs._len;
            rhs._len = 0;
            cout<<"move ctor"<<endl;
        }

    // check array valid
    bool is_up_valid(){
        return _upInt != nullptr;
    }

    private:
        std::unique_ptr<int[]> _upInt; // heavy array resource
        int _len; // length of int array
};

Código de ensaio:

void test_std_move2(){
    ResHeavy rh; // only one int[]
    // operator rh

    // after some operator of rh, it becomes no-use
    // transform it to other object
    ResHeavy rh2 = std::move(rh); // rh becomes invalid

    // show rh, rh2 it valid
    if(rh.is_up_valid())
        cout<<"rh valid"<<endl;
    else
        cout<<"rh invalid"<<endl;

    if(rh2.is_up_valid())
        cout<<"rh2 valid"<<endl;
    else
        cout<<"rh2 invalid"<<endl;

    // new ResHeavy object, created by copy ctor
    ResHeavy rh3(rh2);  // two copy of int[]

    if(rh3.is_up_valid())
        cout<<"rh3 valid"<<endl;
    else
        cout<<"rh3 invalid"<<endl;
}

Saída abaixo:

default ctor
move ctor
rh invalid
rh2 valid
copy ctor
rh3 valid

Podemos ver que std::move com move constructor faz transformar recursos facilmente.

Onde mais está a DST: mover útil?

Std:: mover também pode ser útil ao ordenar uma série de elementos. Muito algoritmos de ordenação (como o selection sort e bubble sort) funcionam trocando pares de elementos. Anteriormente, tivemos de recorrer à semântica copiadora para fazer a troca. Agora podemos usar a semântica do movimento, que é mais eficiente.

Citado:

Https://www.learncpp.com/cpp-tutorial/15-4-stdmove/