L'assegnazione del movimento tramite destruct + move construct è sicura?

Question

Ecco un modo molto semplice per definire l'assegnazione mossa per la maggior parte qualsiasi classe con un costruttore mossa:

class Foo { 
public: 
    Foo(Foo&& foo);      // you still have to write this one 
    Foo& operator=(Foo&& foo) { 
    if (this != &foo) {    // avoid destructing the only copy 
     this->~Foo();     // call your own destructor 
     new (this) Foo(std::move(foo)); // call move constructor via placement new 
    } 
    return *this; 
    } 
    // ... 
}; 

È questa sequenza di chiamare il proprio distruttore seguito da nuova collocazione sul questo puntatore di sicurezza nello standard C++ 11 ?

Answer 1

Solo se non si ottiene mai un tipo da questa classe. Se lo fai, questo trasformerà l'oggetto in una mostruosità. È un peccato che lo standard utilizzi questo come esempio per spiegare le vite degli oggetti. È una cosa veramente brutta da fare nel codice del mondo reale.

Answer 2

Tecnicamente, il codice sorgente è sicuro in questo piccolo esempio. Ma la realtà è che se guardi sempre a Foo, invocherai UB. È così orribilmente pericoloso che non ne vale la pena. Usa lo swap come tutti gli altri - c'è una ragione per questo ed è perché è la scelta giusta. Inoltre, il controllo dell'auto-assegnazione è cattivo.