Oggetti zombi dopo std :: move

Question

Sono confuso sullo stato di un oggetto dopo è stato spostato utilizzando semantica di spostamento C++ 0x. La mia comprensione è che una volta che un oggetto è stato spostato, è ancora un oggetto valido, ma il suo stato interno è stato alterato in modo tale che quando viene chiamato il suo distruttore, nessuna risorsa viene deallocata.

Ma se la mia comprensione è corretta, il distruttore di un oggetto spostato dovrebbe essere chiamato.

Ma, che non accade quando effettuo un semplice test:

struct Foo 
{ 
    Foo() 
    { 
     s = new char[100]; 
     cout << "Constructor called!" << endl; 
    } 

    Foo(Foo&& f) 
    { 
     s = f.s; 
     f.s = 0; 
    } 

    ~Foo() 
    { 
     cout << "Destructor called!" << endl; 
     delete[] s; // okay if s is NULL 
    } 

    void dosomething() { cout << "Doing something..." << endl; } 

    char* s; 
}; 

void work(Foo&& f2) 
{ 
    f2.dosomething(); 
} 

int main() 
{ 
    Foo f1; 
    work(std::move(f1)); 
} 

Questa uscita:

Constructor called! 
Doing something... 
Destructor called! 

Avviso il distruttore viene chiamato una sola volta. Questo dimostra che la mia comprensione qui è spenta. Perché il distruttore non è stato chiamato due volte? Ecco la mia interpretazione di ciò che dovrebbe dovuto accadere:

1. Foo f1 è costruito.
2. Foo f1 è passato a work, che prende un valore di f2.
3. Il costruttore mossa di Foo è chiamato, spostando tutte le risorse in f1 a f2.
4. Ora il distruttore f2 viene chiamato, che rilascia tutte le risorse.
5. Ora f1 s' distruttore viene chiamato, che in realtà non fa nulla dal momento che tutte le risorse sono state trasferite a f2. Tuttavia, il distruttore è chiamato comunque.

Tuttavia, poiché viene chiamato un solo distruttore, il passaggio 4 o il passaggio 5 non si verificano. Ho fatto un backtrace dal distruttore per vedere da dove è stato invocato, e viene richiamato dal passaggio 5. Quindi perché non viene chiamato anche il distruttore f2?

MODIFICA: OK, ho modificato questo in modo che sia effettivamente in grado di gestire una risorsa. (Un buffer di memoria interno.) Tuttavia, ottengo lo stesso comportamento in cui il distruttore viene chiamato solo una volta.

Answer 1

Modifica(Nuovo e risposta corretta)
Siamo spiacenti, guardando più da vicino il codice, sembra che la risposta è molto più semplice: mai richiama il costruttore mossa. Non muovi mai realmente l'oggetto. È sufficiente passare un riferimento di rvalue alla funzione work, che chiama una funzione membro su tale riferimento, che punta ancora all'oggetto originale.

risposta originale, salvato per i posteri

Al fine di eseguire in realtà la mossa, devi avere qualcosa di simile Foo f3(std::move(f2)); all'interno work. Quindi puoi chiamare la funzione membro su f3 che è un nuovo oggetto, creato spostandosi da f

Per quanto posso vedere, non si ottiene affatto la semantica del movimento. Stai solo vedendo una semplice copia di vecchia elisione.

per lo spostamento che si verifica, è necessario utilizzare std::move (o in particolare, l'argomento passato al costruttore deve essere un riferimento di rvalore non denominato/temporaneo), ad esempio quello restituito da std::move). Altrimenti viene trattato come un semplice riferimento lvalue vecchio stile, quindi una copia dovrebbe essere, ma come al solito il compilatore può ottimizzarlo, lasciando che un oggetto venga costruito e un oggetto distrutto.

In ogni caso, anche con la semantica del movimento, non c'è alcun motivo per cui il compilatore non dovrebbe fare la stessa cosa: basta ottimizzare la mossa, proprio come avrebbe ottimizzato la copia. Una mossa è a buon mercato, ma è ancora più economico semplicemente costruire l'oggetto dove serve, piuttosto che costruirne uno, e quindi spostarlo in un'altra posizione e chiamare il distruttore sul primo.

Vale anche la pena notare che si sta utilizzando un compilatore relativamente vecchio e le versioni precedenti delle specifiche non erano molto chiare su cosa dovesse accadere con questi "oggetti zombi". Quindi è possibile che GCC 4.3 non chiami semplicemente il distruttore. Credo che sia solo l'ultima revisione, o forse quella precedente, che richiede esplicitamente che il distruttore sia chiamato

Answer 2

Si prega di notare che il compilatore può ottimizzare la costruzione/distruzione non necessaria, rendendo effettivamente un solo oggetto esistente. Questo è particolarmente vero per i riferimenti di valore (che sono stati inventati esattamente per questo scopo).

Penso che tu abbia torto nella tua interpretazione di cosa succede. Il costruttore di movimento non viene chiamato: se il valore non è temporaneo, il riferimento di rvalore si comporta come un riferimento normale.

Forse this article porterà più informazioni sulla semantica di riferimento rvalore.