Czym jest idiom kopiowanie i wymiana?

Przegląd

Dlaczego potrzebujemy idiomu copy-and-swap?

Każda klasa, która zarządza zasobem (opakowanie , jak inteligentny wskaźnik), musi zaimplementować wielką trójkę . Podczas gdy cele i implementacja konstruktora kopiującego i destruktora są proste, operator kopiującego przypisania jest prawdopodobnie najbardziej dopracowany i trudny. Jak należy to zrobić? Jakich pułapek należy unikać?

Idiom copy-and-swap jest rozwiązanie i elegancko pomaga operatorowi przypisania osiągnąć dwie rzeczy: unikanie powielania kodu i zapewnienie silnej gwarancji wyjątku .

Jak to działa?

Koncepcyjnie , działa poprzez użycie funkcji copy-constructor do utworzenia lokalnej kopii danych, a następnie pobiera skopiowane dane za pomocą funkcji swap, zamieniając stare dane na nowe. Następnie Kopia tymczasowa ulega zniszczeniu, zabierając ze sobą stare dane. Jesteśmy w lewo z kopią nowych danych.

Aby użyć idiomu copy-and-swap, potrzebujemy trzech rzeczy: działającego konstruktora kopiującego, działającego destruktora (oba są podstawą każdego wrappera, więc i tak powinny być kompletne) i swap funkcji.

Funkcja swap jest nie rzucającą funkcją, która zamienia dwa obiekty klasy, member na member. Możemy pokusić się o użycie std::swap zamiast podania własnego, ale byłoby to niemożliwe; std::swap używa konstruktora kopiującego i operatora przyporządkowania kopii w ramach jego implementacji, a ostatecznie będziemy próbować zdefiniować operatora przyporządkowania pod względem samym w sobie!

(nie tylko to, ale niewykwalifikowane wywołania do swap użyją naszego niestandardowego operatora swap, pomijając niepotrzebną budowę i zniszczenie naszej klasy, które pociągnęłyby za sobą std::swap.)

Szczegółowe wyjaśnienie

Cel

#include <algorithm> // std::copy
#include <cstddef> // std::size_t

class dumb_array
{
public:
    // (default) constructor
    dumb_array(std::size_t size = 0)
        : mSize(size),
          mArray(mSize ? new int[mSize]() : nullptr)
    {
    }

    // copy-constructor
    dumb_array(const dumb_array& other)
        : mSize(other.mSize),
          mArray(mSize ? new int[mSize] : nullptr),
    {
        // note that this is non-throwing, because of the data
        // types being used; more attention to detail with regards
        // to exceptions must be given in a more general case, however
        std::copy(other.mArray, other.mArray + mSize, mArray);
    }

    // destructor
    ~dumb_array()
    {
        delete [] mArray;
    }

private:
    std::size_t mSize;
    int* mArray;
};

Ta klasa prawie zarządza tablicą z powodzeniem, ale musi operator= działać poprawnie.

Nieudane rozwiązanie

// the hard part
dumb_array& operator=(const dumb_array& other)
{
    if (this != &other) // (1)
    {
        // get rid of the old data...
        delete [] mArray; // (2)
        mArray = nullptr; // (2) *(see footnote for rationale)

        // ...and put in the new
        mSize = other.mSize; // (3)
        mArray = mSize ? new int[mSize] : nullptr; // (3)
        std::copy(other.mArray, other.mArray + mSize, mArray); // (3)
    }

    return *this;
}

I mówimy, że skończyliśmy; to teraz zarządza tablicą, bez przecieków. Jednak cierpi na trzy problemy, oznaczone kolejno w kodzie jako (n).

1. Pierwszy to test na samodzielne zadanie. To sprawdzanie służy dwóm celom: jest to łatwy sposób, aby uniemożliwić nam uruchamianie niepotrzebnego kodu podczas samodzielnego przypisywania i chroni nas przed subtelnymi błędami (takimi jak usunięcie tablicy tylko po to, aby spróbować ją skopiować). Ale we wszystkich innych przypadkach służy jedynie spowolnieniu programu i działa jak szum w kodzie; samo-przypisanie rzadko się zdarza, więc przez większość czasu ta kontrola jest marnotrawstwem. Byłoby lepiej, gdyby operator mógł pracować prawidłowo bez niego.

2. Drugi jest to, że zapewnia tylko podstawową gwarancję wyjątku. Jeśli new int[mSize] nie powiedzie się, *this zostanie zmodyfikowany. (Mianowicie rozmiar jest zły, a dane zniknęły! W związku z tym, że nie jest to możliwe, nie jest to możliwe.]}

   dumb_array& operator=(const dumb_array& other)
   {
       if (this != &other) // (1)
       {
           // get the new data ready before we replace the old
           std::size_t newSize = other.mSize;
           int* newArray = newSize ? new int[newSize]() : nullptr; // (3)
           std::copy(other.mArray, other.mArray + newSize, newArray); // (3)
   
           // replace the old data (all are non-throwing)
           delete [] mArray;
           mSize = newSize;
           mArray = newArray;
       }
   
       return *this;
   }
   

3. Kod się rozszerzył! Co prowadzi nas do trzeciego problemu: powielanie kodu. Nasz operator przydziałów skutecznie powiela cały kod, który już napisaliśmy gdzie indziej, a to straszna rzecz.

W naszym przypadku, rdzeń to tylko dwie linie (alokacja i kopia), ale przy bardziej złożonych zasobach ten kod może być dość kłopotliwy. Powinniśmy starać się nigdy się nie powtarzać.

(można by się zastanawiać: jeśli ta ilość kodu jest potrzebna do prawidłowego zarządzania jednym zasobem, co jeśli moja klasa zarządza więcej niż jednym? Chociaż może się to wydawać słusznym problemem, a w rzeczywistości wymaga nietrywialnego try/catch klauzule, to nie jest problem. To dlatego, że klasa powinna zarządzać jeden zasób tylko!)

Skuteczne rozwiązanie

Jak wspomniano, idiom Kopiuj i wymieniaj rozwiąże wszystkie te problemy. Ale w tej chwili mamy wszystkie wymagania oprócz jednego: funkcję swap. Podczas gdy reguła trzech z powodzeniem pociąga za sobą istnienie naszego konstruktora kopiującego, operatora przypisania i destruktora, tak naprawdę powinna być nazywana "wielką trójką i pół": za każdym razem, gdy twoja klasa zarządza zasobem, ma również sens, aby zapewnić swap funkcję.

Musimy dodać Zamiana funkcjonalności na naszą klasę, A robimy to w następujący sposób†:

class dumb_array
{
public:
    // ...

    friend void swap(dumb_array& first, dumb_array& second) // nothrow
    {
        // enable ADL (not necessary in our case, but good practice)
        using std::swap;

        // by swapping the members of two objects,
        // the two objects are effectively swapped
        swap(first.mSize, second.mSize);
        swap(first.mArray, second.mArray);
    }

    // ...
};

(tutaj {[44] } jest wyjaśnienie dlaczego public friend swap.) Teraz nie tylko możemy zamienić nasze dumb_array ' s, ale swapy w ogóle mogą być bardziej wydajne; to tylko swapy wskaźników i rozmiarów, zamiast przydzielania i kopiowania całych tablic. Oprócz tego bonusu w zakresie funkcjonalności i wydajności, jesteśmy teraz gotowi wdrożyć idiom Kopiuj i wymieniaj.

Bez dalszych ceregieli, naszym operatorem przypisania jest:

dumb_array& operator=(dumb_array other) // (1)
{
    swap(*this, other); // (2)

    return *this;
}

I to jest to! Jednym zamachem wszystkie trzy problemy są elegancko rozwiązywane naraz.

Dlaczego to działa?

Najpierw zauważamy ważny wybór: argument parametru jest brany przez-wartość. Chociaż można równie łatwo zrobić następujące (i rzeczywiście, wiele naiwnych implementacji idiomu zrobić): {]}

dumb_array& operator=(const dumb_array& other)
{
    dumb_array temp(other);
    swap(*this, temp);

    return *this;
}

Tracimy ważną możliwość optymalizacji . Nie tylko to, ale ten wybór jest krytyczny w C++11, który jest omówiony później. (Na ogólne Uwaga, niezwykle przydatna wskazówka jest następująca: jeśli masz zamiar zrobić kopię czegoś w funkcji, pozwól kompilatorowi zrobić to na liście parametrów.‡)

Tak czy inaczej, ta metoda pozyskiwania naszego zasobu jest kluczem do wyeliminowania duplikacji kodu: możemy użyć kodu z konstruktora kopiującego, aby wykonać kopię i nigdy nie musimy powtarzać żadnego bitu. Teraz, gdy kopia została wykonana, jesteśmy gotowi do wymiany.

Zauważ, że po wprowadzeniu funkcji wszystkie nowe dane są już przydzielone, skopiowane i gotowe do użycia. To daje nam silną gwarancję WYJĄTKÓW za darmo: nie wejdziemy nawet do funkcji, jeśli konstrukcja kopii zawiedzie, i dlatego nie jest możliwe, aby zmienić stan *this. (Co zrobiliśmy ręcznie wcześniej dla silnej gwarancji WYJĄTKÓW, kompilator robi dla nas teraz; jak miło.)

W tym momencie jesteśmy wolni od domu, ponieważ swap nie rzucamy. Zamieniamy nasze bieżące dane z kopiowanymi, bezpiecznie zmieniając nasz stan, a stare dane zostają wprowadzone do tymczasowego. Stare dane są następnie zwalniane, gdy funkcja powróci. (Gdzie na końcu zakresu parametru i wywołany jest jego Destruktor.)

Ponieważ idiom nie powtarza kodu, nie możemy wprowadzać błędów wewnątrz operatora. Zauważ, że oznacza to, że jesteśmy pozbawieni potrzeby samodzielnego sprawdzenia, pozwalając na jednolitą implementację operator=. (Dodatkowo, nie mamy już kary za wykonywanie zadań bez siebie.)

I to jest idiom copy-and-swap.

A co z C++11?

Kolejna wersja C++, C++11, wprowadza jedną bardzo ważną zmianę w sposobie zarządzania zasobami: reguła trzech jest terazregułą czterech (i pół). Dlaczego? Ponieważ nie tylko musimy być w stanie kopiować-konstruować nasz zasób, musimy również go przenosić-konstruować.

Na szczęście dla nas, to proste:

class dumb_array
{
public:
    // ...

    // move constructor
    dumb_array(dumb_array&& other)
        : dumb_array() // initialize via default constructor, C++11 only
    {
        swap(*this, other);
    }

    // ...
};

Więc to, co zrobiliśmy jest proste: zainicjalizować za pomocą domyślnego konstruktora (funkcja C++11), a następnie swap z other; wiemy, że domyślna instancja naszej klasy może być bezpiecznie przypisana i zniszczona, więc wiemy, że {27]} będzie w stanie zrobić to samo, po zamianie.

(zauważ, że niektóre Kompilatory nie obsługują delegowania konstruktorów; w tym przypadku musimy ręcznie domyślnie konstruuj klasę. Jest to niefortunne, ale na szczęście trywialne zadanie.)

Dlaczego to działa?

dumb_array& operator=(dumb_array other); // (1)

Teraz, jeśli other jest inicjalizowana z wartością R, będzie skonstruowana z ruchu . Idealnie. W ten sam sposób C++03 pozwala nam ponownie wykorzystać funkcjonalność copy-constructor C++11 automatycznie wybierze konstruktor move-constructor, jeśli jest to właściwe. (I, oczywiście, jak wspomniano wcześniej w linkowanym artykule, kopiowanie / przenoszenie wartości może zostać całkowicie pominięte.)

I tak kończy się idiom copy-and-swap.

Przypisy

*dlaczego ustawiamy mArray NA null? Ponieważ jeśli jakiś kolejny kod w operatorze rzuca, może zostać wywołany Destruktor dumb_array; a jeśli tak się stanie bez ustawiając ją na null, próbujemy usunąć pamięć, która została już usunięta! Unikamy tego, ustawiając go na null, ponieważ usunięcie null nie jest operacją.

†istnieją inne twierdzenia, że powinniśmy specjalizować się std::swap dla naszego typu, dostarczać w klasie swap wzdłuż boku funkcji swobodnej swap itd. Ale to wszystko jest niepotrzebne: jakiekolwiek właściwe użycie swap będzie przez wywołanie bez zastrzeżeń, a nasza funkcja zostanie znaleziona przez ADL . Wystarczy jedna funkcja.

‡powodem jest proste: gdy masz zasób dla siebie, możesz go zamienić i / lub przenieść (C++11) w dowolne miejsce. Wykonując kopię na liście parametrów, maksymalizujesz optymalizację.