L'oggetto spostato da essere lasciato in uno stato "sicuro"?

Question

Eventuali duplicati:
How can moved objects be used?
What constitutes a valid state for a “moved from” object in C++11?

Nell'attuare semantica di movimento in C++ 11, dovrebbe il mosso-dall'oggetto essere lasciato in uno stato sicuro , o può viene lasciato in uno stato "spazzatura"?

ad es. Qual è l'opzione preferita per implementare il costruttore di movimento nel seguente esempio di un wrapper C++ 11 a una risorsa raw FILE*?

// C++11 wrapper to raw FILE* 
class File 
{ 
    FILE* m_fp; 

public: 

    // Option #1 
    File(File&& other) 
    : m_fp(other.m_fp) 
    { 
    // "other" left in a "junk" state 
    } 

    // Option #2 
    File(File&& other) 
    : m_fp(other.m_fp) 
    { 
    // Avoid dangling reference in "other" 
    other.m_fp = nullptr; 
    } 

    ... 
}; 

Answer 1

L'unica cosa che si deve essere in grado di fare con un spostato da-oggetto è distruggerla. Oltre a ciò, dipende dalla tua classe quali sono gli invarianti di classe normali e se spostati, dagli oggetti che si preoccupano di soddisfarli.

Ad esempio, è una buona idea assicurarsi di poter assegnare l'oggetto, nel caso in cui qualcuno voglia utilizzare std::move su un'istanza e assegnargli un nuovo valore in un secondo momento. [Modifica: come indicato in una risposta a una delle domande suggerite-dupe, il modello generale std::swap si sposta da un oggetto e quindi sposta-assegna ad esso, quindi se non lo si assicura, allora è necessario specializzarsi su std::swap o devi proibire agli utenti della tua classe di usarlo.]

Poiché la tua classe non fa nulla nel suo distruttore, l'opzione va bene. L'opzione 2 potrebbe essere più semplice con cui gli utenti possono lavorare, ma poi, se stanno codificando sul presupposto che non possono fare nulla con un oggetto spostato da, allora non fa alcuna differenza. Poiché la classe è incompleta, tuttavia, ciò potrebbe cambiare quando si scrive il distruttore.

Answer 2

Un oggetto che è stato spostato da ancora un oggetto, e deve essere in uno stato valido , anche se può essere indeterminato. In particolare, dovrebbe essere possibile assegnare a un nuovo valore in modo sicuro (e, naturalmente, deve essere distruttibile, come dice @Steve). Spetta a te quale particolare semantica vuoi assegnare alla tua classe, purché un oggetto spostato da esso rimanga valido.

In generale, si dovrebbe pensare a "spostare" come una "copia" ottimizzata. Tuttavia, per alcune classi che sono in ­ trin ­ siccome "solo-spostamento", ad esempio unique_ptr, potrebbero essere appropriate garanzie aggiuntive – ad esempio, unique_ptr promette che dopo che è stato spostato, da esso è nullo, e sicuramente nient'altro in realtà ha senso.

(Il codice attuale è incompleta, ma dato che un FILE* è una sorta-di risorse mossa sola, probabilmente è rotto e si dovrebbe cercare di emulare unique_ptr il più vicino possibile – o addirittura use it directly.)