¿Cuál es la forma "correcta" de escribir Copiar/Mover/operador = trío en C++ 11?

Question

En este punto, escribir el constructor de copia y el par de operadores de asignación está bien definido; una búsqueda rápida le llevará a muchos éxitos sobre cómo codificarlos adecuadamente.

Ahora que el constructor de movimientos ha entrado en la mezcla, ¿hay una nueva "mejor" manera?

Answer 1

Preferiblemente, pero serán = default;, ya que los tipos de miembro deben ser de la gestión de recursos tipos que ocultan los detalles del movimiento que, al igual que std::unique_ptr. Solo los implementadores de esos tipos de "bajo nivel" deberían molestarse en lidiar con eso.

Recuerde que solo necesita preocuparse por la semántica de movimiento si tiene un recurso externo (para su objeto). Es completamente inútil para tipos "planos".

Answer 2

Esto es lo que se me ocurrió, pero no sé si existe una solución más óptima.

class MyClass 
{ 
    void Swap(MyClass &other) 
    { 
     std::swap(other.member, member); 
    } 

public: 
    MyClass() 
     : member() 
    { 
    } 

    MyClass(const MyClass &other) 
     : member(other.member) 
    { 
    } 

    MyClass(MyClass &&other) 
     : member(std::move(other.member)) 
    { 
    } 

    MyClass &operator=(MyClass other) 
    { 
     other.Swap(*this); 
     return *this; 
    } 

private: 
    int member; 
}; 

Answer 3

La mejor manera es dejar que el compilador los genere a todos. También fue el mejor enfoque en C++ 03 y si lograste hacer esto, tus clases de C++ 03 se convertirán automáticamente en "habilitadas para mover" cuando migres a C++ 11. La mayoría de los problemas de gestión de recursos pueden resolverse escribiendo solo los constructores no copiados y destructores de clases de gestión de un solo recurso y solo haciendo clases compuestas usando estos, además de punteros inteligentes (p. Ej. std::unique_ptr) y clases de contenedor para construir objetos más ricos. .

Answer 4

Usando sonido metálico/libC++:

#include <chrono> 
#include <iostream> 
#include <vector> 

#if SLOW_DOWN 

class MyClass 
{ 
    void Swap(MyClass &other) 
    { 
     std::swap(other.member, member); 
    } 

public: 
    MyClass() 
     : member() 
    { 
    } 

    MyClass(const MyClass &other) 
     : member(other.member) 
    { 
    } 

    MyClass(MyClass &&other) 
     : member(std::move(other.member)) 
    { 
    } 

    MyClass &operator=(MyClass other) 
    { 
     other.Swap(*this); 
     return *this; 
    } 

private: 
    int member; 
}; 

#else 

class MyClass 
{ 
public: 
    MyClass() 
     : member() 
    { 
    } 

private: 
    int member; 
}; 

#endif 

int main() 
{ 
    typedef std::chrono::high_resolution_clock Clock; 
    typedef std::chrono::duration<float, std::milli> ms; 
    auto t0 = Clock::now(); 
    for (int k = 0; k < 100; ++k) 
    { 
     std::vector<MyClass> v; 
     for (int i = 0; i < 1000000; ++i) 
      v.push_back(MyClass()); 
    } 
    auto t1 = Clock::now(); 
    std::cout << ms(t1-t0).count() << " ms\n"; 
} 

$ clang++ -stdlib=libc++ -std=c++11 -O3 -DSLOW_DOWN test.cpp 
$ a.out 
519.736 ms 
$ a.out 
517.036 ms 
$ a.out 
524.443 ms 

$ clang++ -stdlib=libc++ -std=c++11 -O3 test.cpp 
$ a.out 
463.968 ms 
$ a.out 
458.702 ms 
$ a.out 
464.441 ms 

Esto se parece a aproximadamente un 12% de diferencia de velocidad en esta prueba.

Explicación: Una de estas definiciones tiene un constructor de copia trivial y un operador de asignación de copia. El otro no. "Trivial" tiene un significado real en C++ 11. Significa que la implementación puede usar memcpy para copiar su clase. O incluso para copiar grandes matrices de tu clase. Entonces, lo mejor es hacer que tus miembros especiales sean triviales si puedes. Eso significa dejar que el compilador los defina. Aunque todavía puede declararlos con = default si lo prefiere.