Uso correcto de `= delete` para métodos en las clases

Question

¿El siguiente snipplet es correcto para des-definir todos los métodos y constructores generados para una clase?

struct Picture { 

    // 'explicit': no accidental cast from string to Picture 
    explicit Picture(const string &filename) { /* load image from file */ } 

    // no accidental construction, i.e. temporaries and the like 
    Picture() = delete; 

    // no copy 
    Picture(const Picture&) = delete; 

    // no assign 
    Picture& operator=(const Picture&) = delete; 

    // no move 
    Picture(Picture&&) = delete; 

    // no move-assign 
    Picture& operator=(Picture&&) = delete; // return type correct? 
}; 

Esto elimina todas las implementaciones del compilador predeterminado y solo abandona el destructor, ¿verdad? Sin eso, la clase sería (casi) inservible, supongo, pero podría eliminarla también, ¿correcto?

¿El tipo de retorno Picture& del movimiento-asigne operator=(Picture&&) correcto? ¿Hace una diferencia si escribí Picture&& para el tipo de devolución?

Answer 1

Además de la respuesta de Xeo:

Sí, todo está correcto. Si quieres puedes eliminar todos los miembros eliminados, pero el constructor de copia borrado y de asignación de copia borrada y tienen el mismo efecto:

struct Picture { // Also ok 

    // 'explicit': no accidental cast from string to Picture 
    explicit Picture(const string &filename) { /* load image from file */ } 

    // no copy 
    Picture(const Picture&) = delete; 

    // no assign 
    Picture& operator=(const Picture&) = delete; 
}; 

La declaración expresa del constructor de copia inhibe la generación implícita del constructor por defecto, mover constructor y mover miembros de la asignación. La eliminación explícita de estos miembros es una cuestión de gusto. Algunos probablemente lo vean como una buena documentación. Otros pueden verlo como excesivamente detallado.

Answer 2

Me parece bien. El valor de retorno de operator=debe ser ser una referencia normal, incluso si el objeto se construye a partir de una referencia rvalue. Esto se debe a que no puede simplemente compilar un lvalue (*this) a un valor r.
Y debería tomar esa referencia rvalue por no const Picture& operator=(Picture&&). ¿Cómo te moverías de un objeto constante? ;)