Jaki jest "prawidłowy" sposób zapisu Copy/Move/operator = trio w C++ 11?

Question

W tym momencie pisanie konstruktora kopiowania i pary operatorów przypisania jest dobrze zdefiniowane; szybkie wyszukiwanie doprowadzi Cię do wielu trafień, jak poprawnie je zakodować.

Teraz, gdy konstruktor ruchu wszedł w miks, czy istnieje nowy "najlepszy" sposób?

Answer 1

Korzystnie, oni po prostu być = default;, ponieważ typy członkowskie powinny mieć typów zasobów zarządzania, które ukrywają szczegóły przejść od ciebie, jak std::unique_ptr. Tylko wykonawcy tych typów "niskiego poziomu" powinni sobie z tym poradzić.

Pamiętaj, że musisz tylko przeszkadzać w semantyce ruchu, jeśli posiadasz zewnętrzny zasób (do obiektu). Jest zupełnie bezużyteczny w przypadku typów "płaskich".

Answer 2

Oto, co wymyśliłem, ale nie wiem, czy istnieje bardziej optymalne rozwiązanie.

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

Najlepszym sposobem jest pozwolić kompilatorowi generować je wszystkie. Było to również najlepsze podejście w C++ 03 i jeśli udało ci się to zrobić, twoje klasy C++ 03 automatycznie stają się "przenoszone" po migracji do C++ 11.

Większość problemów związanych z zarządzaniem zasobami można rozwiązać, pisząc tylko niekopiowane konstruktory i destruktory klas zarządzających jednym zasobem, a następnie używając tylko tych klas złożonych oraz inteligentne wskaźniki (np. std::unique_ptr) i klasy kontenerów, aby budować bogatsze obiekty .

Answer 4

Korzystanie clang/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 

To wygląda jak około 12% różnicy prędkości na tym teście.

Objaśnienie: Jedna z tych definicji ma trywialny konstruktor kopiowania i operator przypisania kopiowania. Drugi nie. "Trivial" ma prawdziwe znaczenie w C++ 11. Oznacza to, że implementacja może używać klasy memcpy do kopiowania. Lub nawet skopiować duże tablice twojej klasy. Więc najlepiej jest sprawić, by twoi wyjątkowi członkowie byli banalni, jeśli możesz. Oznacza to, że pozwala to kompilatorowi je zdefiniować. Chociaż nadal możesz je zadeklarować pod numerem = default, jeśli wolisz.