¿Qué es std :: move (), y cuándo debería usarse?

1. ¿Qué es?
2. ¿Qué hace?
3. ¿Cuándo debería usarse?

Se agradecen los buenos enlaces.

Página de Wikipedia sobre referencias de valor R de C ++ 11 y constructores de movimiento

1. En C ++ 11, además de copiar constructores, los objetos pueden tener constructores de movimiento.
   (Y además de copiar operadores de asignación, tienen operadores de asignación de movimiento).
2. El constructor de movimiento se usa en lugar del constructor de copia, si el objeto tiene el tipo "rvalue-reference" (Type && ).
3. std::move() es un modelo que produce una referencia de valor r a un objeto, para permitir moverse desde él.

Es una nueva forma de C ++ para evitar copias. Por ejemplo, usando un constructor de movimiento, a std::vectorpodría simplemente copiar su puntero interno a los datos al nuevo objeto, dejando el objeto movido en un estado movido desde, por lo tanto, no copiando todos los datos. Esto sería C ++ - válido.

Intente buscar en Google la semántica del movimiento, el valor, el reenvío perfecto.

1. "¿Qué es?"

Si bien std::move() técnicamente es una función, diría que no es realmente una función . Es una especie de convertidor entre las formas en que el compilador considera el valor de una expresión.

2. "¿Qué hace?"

Lo primero a tener en cuenta es que std::move() realidad no mueve nada . Convierte una expresión de ser un valor l (como una variable con nombre) a ser un valor x . Un xvalue le dice al compilador:

Puedes saquearme, mover todo lo que tengo y usarlo en otro lugar (ya que de todos modos voy a ser destruido pronto) ".

en otras palabras, cuando usas std::move(x), estás permitiendo que el compilador canibalice x. Por lo tanto, si xtiene, por ejemplo, su propio búfer en la memoria, después destd::move() de que el compilador puede tener otro objeto propio.

_{También puedes moverte desde un valor priva (como un temporal que estás pasando), pero esto rara vez es útil.}

3. "¿Cuándo se debe usar?"

Otra forma de hacer esta pregunta es "¿Para qué canibalizaría los recursos de un objeto existente?" bueno, si estás escribiendo código de aplicación, probablemente no estarás jugando mucho con objetos temporales creados por el compilador. Por lo tanto, principalmente haría esto en lugares como constructores, métodos de operador, funciones similares a algoritmos de biblioteca estándar, etc., donde los objetos se crean y destruyen mucho de forma automática. Por supuesto, eso es solo una regla general.

Un uso típico es 'mover' recursos de un objeto a otro en lugar de copiarlos. @Guillaume enlaza a esta página que tiene un ejemplo breve y sencillo: intercambiar dos objetos con menos copia.

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)
}

El uso de mover le permite intercambiar los recursos en lugar de copiarlos:

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

Piense en lo que sucede cuando Tes, por ejemplo, vector<int>de tamaño n. En la primera versión, lee y escribe 3 * n elementos, en la segunda versión básicamente lee y escribe solo los 3 punteros en los buffers de los vectores, más los tamaños de los 3 buffers. Por supuesto, la clase Tnecesita saber cómo moverse; su clase debe tener un operador de asignación de movimiento y un constructor de movimiento para la clase Tpara que esto funcione.

Puede usar move cuando necesite "transferir" el contenido de un objeto a otro lugar, sin hacer una copia (es decir, el contenido no está duplicado, por eso podría usarse en algunos objetos no copiables, como un unique_ptr). También es posible que un objeto tome el contenido de un objeto temporal sin hacer una copia (y ahorre mucho tiempo), con std :: move.

Este enlace realmente me ayudó:

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

Lo siento si mi respuesta llega demasiado tarde, pero también estaba buscando un buen enlace para std :: move, y encontré los enlaces de arriba un poco "austeros".

Esto pone el énfasis en la referencia del valor r, en qué contexto debe usarlos, y creo que es más detallado, por eso quería compartir este enlace aquí.

Q: que es std::move ?

UNA: std::move() es una función de la Biblioteca estándar de C ++ para convertir a una referencia de valor r.

Simplísticamente std::move(t)es equivalente a:

static_cast<T&&>(t);

Un valor r es un temporal que no persiste más allá de la expresión que lo define, como un resultado de función intermedia que nunca se almacena en una variable.

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

Se proporciona una implementación para std :: move () en N2027: "Una breve introducción a las referencias de Rvalue" de la siguiente manera:

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

Como puede ver, std::movedevuelve T&&sin importar si se llama con un valor ( T), tipo de referencia ( T&) o rvalue reference ( T&&).

P: ¿Qué hace?

A: Como un elenco, no hace nada durante el tiempo de ejecución. Solo es relevante en el momento de la compilación decirle al compilador que le gustaría continuar considerando la referencia como un valor.

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)`

Lo que no hace:

• Haga una copia del argumento.
• Llame al constructor de la copia.
• Cambiar el objeto de argumento

P: ¿Cuándo se debe usar?

R: Debe usarlo std::movesi desea llamar a funciones que admiten la semántica de movimiento con un argumento que no es un valor r (expresión temporal).

Esto me plantea las siguientes preguntas de seguimiento:

• ¿Qué son las semánticas de movimiento? La semántica de movimiento en contraste con la semántica de copia es una técnica de programación en la que los miembros de un objeto se inicializan 'tomando el control' en lugar de copiar los miembros de otro objeto. Tal 'toma de control' solo tiene sentido con punteros y controladores de recursos, que pueden transferirse de forma económica copiando el puntero o el controlador de enteros en lugar de los datos subyacentes.

• ¿Qué tipo de clases y objetos admiten la semántica de movimiento? Depende de usted como desarrollador implementar la semántica de movimiento en sus propias clases si se beneficiarían de transferir a sus miembros en lugar de copiarlos. Una vez que implemente la semántica de movimiento, se beneficiará directamente del trabajo de muchos programadores de bibliotecas que han agregado soporte para manejar clases con semántica de movimiento de manera eficiente.

• ¿Por qué el compilador no puede resolverlo por sí solo? El compilador no puede simplemente llamar a otra sobrecarga de una función a menos que usted lo diga. Debe ayudar al compilador a elegir si se debe llamar a la versión de función regular o mover.

• ¿En qué situaciones me gustaría decirle al compilador que debe tratar una variable como un valor r? Lo más probable es que esto suceda en las funciones de plantilla o biblioteca, donde sabe que se puede recuperar un resultado intermedio.

std :: move en sí realmente no hace mucho. Pensé que llamaba al constructor movido para un objeto, pero en realidad solo realiza una conversión de tipo (convirtiendo una variable lvalue en un rvalue para que dicha variable pueda pasarse como argumento a un constructor de movimiento u operador de asignación).

Por lo tanto, std :: move solo se usa como precursor para usar la semántica de movimiento. La semántica de movimiento es esencialmente una forma eficiente de tratar con objetos temporales.

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

Este es un código atractivo, pero E + F produce un objeto temporal. Entonces D + temp produce otro objeto temporal y así sucesivamente. En cada operador "+" normal de una clase, se producen copias profundas.

Por ejemplo

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

La creación del objeto temporal en esta función es inútil: estos objetos temporales se eliminarán al final de la línea de todos modos a medida que salgan del alcance.

Podemos utilizar la semántica de movimiento para "saquear" los objetos temporales y hacer algo como

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

Esto evita que se realicen copias innecesarias en profundidad. Con referencia al ejemplo, la única parte donde se produce una copia profunda ahora es E + F. El resto usa semántica de movimiento. El constructor de movimientos u operador de asignación también debe implementarse para asignar el resultado a A.

"¿Qué es?" y "¿Qué hace?" ha sido explicado anteriormente.

Daré un ejemplo de "cuándo debería usarse".

Por ejemplo, tenemos una clase con muchos recursos como gran matriz.

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 prueba:

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;
}

salida de la siguiente manera:

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

Podemos ver que std::movecon move constructormake transforma el recurso fácilmente.

¿Dónde más es std::moveútil?

std::moveTambién puede ser útil al ordenar una matriz de elementos. Muchos algoritmos de ordenación (como la ordenación por selección y la ordenación por burbujas) funcionan intercambiando pares de elementos. Anteriormente, hemos tenido que recurrir a la semántica de copia para hacer el intercambio. Ahora podemos usar la semántica de movimiento, que es más eficiente.

También puede ser útil si queremos mover los contenidos administrados por un puntero inteligente a otro.

Citado:

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

Aquí hay un ejemplo completo, usando std :: move para un vector personalizado (simple)

Rendimiento esperado:

 c: [10][11]
 copy ctor called
 copy of c: [10][11]
 move ctor called
 moved c: [10][11]

Compilar como:

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Código:

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
    std::cout << "c: " << *c << std::endl;
    auto d = *c;
    std::cout << "copy of c: " << d << std::endl;
    auto e = std::move(*c);
    delete c;
    std::cout << "moved c: " << e << std::endl;
}