La diferencia entre el tipo de fundición y el uso de std :: move()?

Question

Tengo un poco de curiosidad acerca de la nueva función std :: move() que acaba de agregarse al nuevo estándar de C++.

terminado de leer un artículo sobre él, y se informó que la definición de la función es

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

esto parece que no tiene ninguna diferencia entre llamar std :: viaje y necesita usar la fundición.

Por ejemplo aquí,

class NPC{ 
    int m_number1; 
    int m_number2; 
public: 
    NPC() : m_number1(1), m_number2(2) { 
     cout << "NPC Constructor called!" << endl; 
    } 

    NPC(NPC&& _npc) : m_number1(_npc.m_number1), m_number2(_npc.m_number2) { 
     _npc.m_number1 = 0; 
     _npc.m_number2 = 0; 

     cout << "NPC Move Constructor called!" << endl; 
    } 
}; 


int main() { 
    NPC n1; 
    NPC n2 = std::move(n1); 

    cout << "----------------" << endl; 
    NPC n3; 
    NPC n4 = (NPC&&)n3; 
    return 0; 
} 

Es correcto pensar que prácticamente no hay diferencia? Bueno, estoy bastante seguro de que estoy en lo correcto, pero también sé que tener demasiada confianza siempre es contraproducente.

¡Gracias de antemano!

Answer 1

std::move se define como un elenco especializada:

static_cast<typename remove_reference<T>::type&&>(t) 

Usted podría hacer esto si realmente quiere. Pero sería mucho más corto y obvio para todos lo que está haciendo si solo usa std::move. Las reglas alrededor de & & de fundición son raras, por lo que es mejor usar move y forward cuando a eso se refiere.

Answer 2

Sí, std::move no hace nada en términos de funcionalidad. Su objetivo es convertir un lvalue en un valor x, lo que hace que el resultado sea movible. Es mejor que usar un yeso porque aclara el propósito.

Answer 3

No hay diferencia en cuanto a la funcionalidad, pero existe una diferencia de legibilidad.

Así como while bucles son preferibles a goto s, y C moldes estilo ++ son preferibles a los de estilo C yesos, std::move se prefiere a la fundición, ya que es una herramienta general menos, y lo que es más fácil de entender lo que es haciendo sin necesidad de investigar la estructura del código más allá.