La función y el uso de std:move() en C++11

Documento oficial: http://www.cplusplus.com/reference/utility/move/?kw=move

Función: Devuelve la referencia de valor r del parámetro entrante. El concepto de referencia de rvalue solo se propuso en C++11. Antes de eso, solo había un tipo de cita.

Pros: llamar a esta función no provocará carreras de datos. (Llamar a esta función no introduce carreras de datos).

说明：

Esta es una función de ayuda para forzar  la semántica de movimiento  en los valores, incluso si tienen un nombre: el uso directo del valor devuelto hace que arg se considere un  rvalue .

En general, los valores r son valores cuya dirección no se puede obtener desreferenciandolos, ya sea porque son literales o porque son de naturaleza temporal (como valores devueltos por funciones o llamadas explícitas al constructor). Al pasar un objeto a esta función   se obtiene un rvalue que hace referencia a él.

Muchos componentes de la biblioteca estándar implementan  la semántica de movimiento , lo que permite transferir la propiedad de los activos y las propiedades de un objeto directamente sin tener que copiarlos cuando el argumento es un  valor r..

Aunque tenga en cuenta que, en la biblioteca estándar,  mover  implica que el  objeto desde el que se movió  se deja en un estado válido pero no especificado. Lo que significa que, después de tal operación, el valor del  objeto movido  solo debe destruirse o asignarse un nuevo valor; si se accede a él, se obtiene un valor no especificado.

En general, los rvalues ​​son valores cuya dirección no se puede obtener desreferenciando porque son de naturaleza literal o temporal (por ejemplo, valores devueltos por funciones o constructores explícitos). Al pasar un objeto a esta función, se puede obtener un rvalue que se refiere a ese objeto.

Muchos componentes de la biblioteca estándar implementan la semántica de movimiento, lo que permite que la propiedad de los activos y las propiedades de un objeto se transfieran directamente sin copiar los argumentos cuando son valores r.

Tenga en cuenta, en la biblioteca estándar, que mover significa que el objeto desde el que se mueve está en un estado válido pero no especificado. Esto significa que después de esta operación, solo el valor movido fuera del objeto debe destruirse o asignarse un nuevo valor; de lo contrario, acceder a él arroja un valor no especificado.

Mira el código de ejemplo:

// move example
#include <utility>      // std::move
#include <iostream>     // std::cout
#include <vector>       // std::vector
#include <string>       // std::string

int main () {
  std::string foo = "foo-string";
  std::string bar = "bar-string";
  std::vector<std::string> myvector;

  myvector.push_back (foo);                    // copies
  myvector.push_back (std::move(bar));         // moves

  std::cout << "myvector contains:";
  for (std::string& x:myvector) std::cout << ' ' << x;
  std::cout << '\n';
  
  std::cout << "foo:"<<foo<<'\n';
  std::cout << "bar:"<<bar<<std::endl;

  return 0;
}

La salida es la siguiente:

myvector contains: foo-string bar-string
foo:foo-string
bar:

Ver la función de movimiento.

Vea si no usa std::move() para comparar:

// move example
#include <utility>      // std::move
#include <iostream>     // std::cout
#include <vector>       // std::vector
#include <string>       // std::string

int main () {
  std::string foo = "foo-string";
  std::string bar = "bar-string";
  std::vector<std::string> myvector;

  myvector.push_back (foo);                    // copies
  myvector.push_back (bar);         // moves

  std::cout << "myvector contains:";
  for (std::string& x:myvector) std::cout << ' ' << x;
  std::cout << '\n';
  
  std::cout << "foo:"<<foo<<'\n';
  std::cout << "bar:"<<bar<<std::endl;

  return 0;
}

La salida es la siguiente:

myvector contains: foo-string bar-string
foo:foo-string
bar:bar-string

La explicación de este ejemplo en la referencia:

La primera llamada a  myvector.push_back copia el valor de foo en el vector (foo mantiene el valor que tenía antes de la llamada).
La segunda llamada mueve el valor de la barra al vector. Esto transfiere su contenido al vector (mientras que bar pierde su valor y ahora está en un estado válido pero no especificado).

La primera llamada a myvector.push_back copiará el valor de foo en el vector (foo retiene el valor antes de la llamada).
La segunda llamada mueve el valor de la barra al vector. Esto transfiere su contenido al vector (mientras que bar pierde su valor y ahora se encuentra en un estado válido pero no especificado).