La differenza tra digitare cast e usare std :: move()?

Question

Sono solo un po 'curioso della nuova funzione std :: move() che è stata appena aggiunta al più recente standard C++.

finito di leggere un articolo su di esso e ha scoperto che la definizione della funzione è

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

Questo sembra che non ha alcuna differenza tra chiamata std :: mossa e l'utilizzo di casting.

Per esempio qui,

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

è giusto pensare che non v'è praticamente alcuna differenza? Beh, sono abbastanza sicuro di aver ragione, ma so anche che essere troppo fiducioso si ritorce sempre.

Grazie in anticipo!

Answer 1

std::move è definito come un cast specializzata:

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

Si potrebbe fare questo se si vuole veramente. Ma sarebbe molto più breve e ovvio per tutti quello che stai facendo se usi semplicemente std::move. Le regole attorno al casting & & sono strane, quindi è meglio usare solo move e forward quando questo è ciò che intendi.

Answer 2

Sì, std::move non fa nulla in termini di funzionalità. Il suo scopo è convertire un lvalue in un valore x, che rende il risultato mobile. È meglio che usare un cast perché rende chiaro lo scopo.

Answer 3

Non c'è alcuna differenza nella funzionalità, ma c'è una differenza nella leggibilità.

Proprio come while cicli sono preferiti a goto s, e C++ calchi stile sono da preferire allo stile C cast, std::move è preferito alla fusione, perché è uno strumento generale meno, e quindi è più facile da capire di cosa si tratta fare senza dover indagare ulteriormente sulla struttura del codice.