Porady: zapisywanie konstruktora przenoszenia

Artykuł
06/09/2015

W tym temacie opisano, jak napisać konstruktor przenoszący oraz operator przypisania przenoszenia dla klasy języka C++.Konstruktor przenoszący umożliwia wdrożenie semantyki ruchu, która może znacznie zwiększyć wydajność aplikacji.Aby uzyskać więcej informacji dotyczących semantyki przenoszenia, zobacz Deklarator odwołania do wartości R: &&.

Temat ten podaje więcej informacji o klasie języka C++, MemoryBlock, która zarządza buforem pamięci.

// MemoryBlock.h
#pragma once
#include <iostream>
#include <algorithm>

class MemoryBlock
{
public:

   // Simple constructor that initializes the resource.
   explicit MemoryBlock(size_t length)
      : _length(length)
      , _data(new int[length])
   {
      std::cout << "In MemoryBlock(size_t). length = "
                << _length << "." << std::endl;
   }

   // Destructor.
   ~MemoryBlock()
   {
      std::cout << "In ~MemoryBlock(). length = "
                << _length << ".";
      
      if (_data != NULL)
      {
         std::cout << " Deleting resource.";
         // Delete the resource.
         delete[] _data;
      }

      std::cout << std::endl;
   }

   // Copy constructor.
   MemoryBlock(const MemoryBlock& other)
      : _length(other._length)
      , _data(new int[other._length])
   {
      std::cout << "In MemoryBlock(const MemoryBlock&). length = " 
                << other._length << ". Copying resource." << std::endl;

      std::copy(other._data, other._data + _length, _data);
   }

   // Copy assignment operator.
   MemoryBlock& operator=(const MemoryBlock& other)
   {
      std::cout << "In operator=(const MemoryBlock&). length = " 
                << other._length << ". Copying resource." << std::endl;

      if (this != &other)
      {
         // Free the existing resource.
         delete[] _data;

         _length = other._length;
         _data = new int[_length];
         std::copy(other._data, other._data + _length, _data);
      }
      return *this;
   }

   // Retrieves the length of the data resource.
   size_t Length() const
   {
      return _length;
   }

private:
   size_t _length; // The length of the resource.
   int* _data; // The resource.
};

W poniższych procedurach opisano jak napisać konstruktor przenoszący i operator przypisania przenoszenia dla przykładowej klasy języka C++.

Aby utworzyć konstruktor przenoszący dla klasy języka C++

Zdefiniuj metodę pustego konstruktora, która ma odwołanie r-wartości do typu klasy jako parametr, jak pokazano w następującym przykładzie:
```
MemoryBlock(MemoryBlock&& other)
   : _data(NULL)
   , _length(0)
{
}
```
W konstruktorze przenoszącym przypisz elementy członkowskie danych klasy z obiektu źródłowego do obiektu, który jest konstruowany:
```
_data = other._data;
_length = other._length;
```
Przypisz elementy członkowskie danych obiektu źródłowego do wartości domyślnych.Zapobiega to wielokrotnemu zwalnianiu zasobów (takich jak pamięć) przez destruktor:
```
other._data = NULL;
other._length = 0;
```

Aby utworzyć operator przypisania przenoszenia dla klasy języka C++

Zdefiniuj pusty operator przypisania, który przyjmuje odwołanie r-wartości do typu klasy jako parametr i zwraca odwołanie do typu klasy, jak pokazano w następującym przykładzie:
```
MemoryBlock& operator=(MemoryBlock&& other)
{
}
```
W operatorze przypisywania przenoszenia dodaj instrukcję warunkową, która nie wykonuje żadnej operacji, jeśli użytkownik próbuje przypisać obiekt do siebie.
```
if (this != &other)
{
}
```
W instrukcji warunkowej zwolnij wszystkie zasoby (takie jak pamięć) z obiektu, do którego trwa przypisywanie.

Poniższy przykład powoduje zwolnienie członka _data z obiektu, który jest przypisany do:
```
// Free the existing resource.
delete[] _data;
```
Wykonaj kroki 2 i 3 w pierwszej procedury, aby przenieść elementy członkowskie danych z obiektu źródłowego do obiektu, który jest generowany:
```
// Copy the data pointer and its length from the 
// source object.
_data = other._data;
_length = other._length;

// Release the data pointer from the source object so that
// the destructor does not free the memory multiple times.
other._data = NULL;
other._length = 0;
```
Zwróć odwołanie do bieżącego obiektu, jak pokazano w następującym przykładzie:
```
return *this;
```

Przykład

Poniższy przykład ukazuje kompletny konstruktor przenoszący i operator przypisania przenoszenia dla klasy MemoryBlock:

// Move constructor.
MemoryBlock(MemoryBlock&& other)
   : _data(NULL)
   , _length(0)
{
   std::cout << "In MemoryBlock(MemoryBlock&&). length = " 
             << other._length << ". Moving resource." << std::endl;

   // Copy the data pointer and its length from the 
   // source object.
   _data = other._data;
   _length = other._length;

   // Release the data pointer from the source object so that
   // the destructor does not free the memory multiple times.
   other._data = NULL;
   other._length = 0;
}

// Move assignment operator.
MemoryBlock& operator=(MemoryBlock&& other)
{
   std::cout << "In operator=(MemoryBlock&&). length = " 
             << other._length << "." << std::endl;

   if (this != &other)
   {
      // Free the existing resource.
      delete[] _data;

      // Copy the data pointer and its length from the 
      // source object.
      _data = other._data;
      _length = other._length;

      // Release the data pointer from the source object so that
      // the destructor does not free the memory multiple times.
      other._data = NULL;
      other._length = 0;
   }
   return *this;
}

Poniższy przykład ukazuje, jak semantyka przenoszenia może zwiększyć wydajność aplikacji.W przykładzie dodano dwa elementy do obiektu wektorowego a następnie wstawiono nowy element między dwa istniejące elementy.W programie Visual C++ 2010 klasa vector używa semantyki przenoszenia do wykonania operacji wstawiania efektywnie przez przeniesienie elementów wektora, nie zaś ich kopiowanie.

// rvalue-references-move-semantics.cpp
// compile with: /EHsc
#include "MemoryBlock.h"
#include <vector>

using namespace std;

int main()
{
   // Create a vector object and add a few elements to it.
   vector<MemoryBlock> v;
   v.push_back(MemoryBlock(25));
   v.push_back(MemoryBlock(75));

   // Insert a new element into the second position of the vector.
   v.insert(v.begin() + 1, MemoryBlock(50));
}

Ten przykład generuje następujące wyniki:

In MemoryBlock(size_t). length = 25.
In MemoryBlock(MemoryBlock&&). length = 25. Moving resource.
In ~MemoryBlock(). length = 0.
In MemoryBlock(size_t). length = 75.
In MemoryBlock(MemoryBlock&&). length = 25. Moving resource.
In ~MemoryBlock(). length = 0.
In MemoryBlock(MemoryBlock&&). length = 75. Moving resource.
In ~MemoryBlock(). length = 0.
In MemoryBlock(size_t). length = 50.
In MemoryBlock(MemoryBlock&&). length = 50. Moving resource.
In MemoryBlock(MemoryBlock&&). length = 50. Moving resource.
In operator=(MemoryBlock&&). length = 75.
In operator=(MemoryBlock&&). length = 50.
In ~MemoryBlock(). length = 0.
In ~MemoryBlock(). length = 0.
In ~MemoryBlock(). length = 25. Deleting resource.
In ~MemoryBlock(). length = 50. Deleting resource.
In ~MemoryBlock(). length = 75. Deleting resource.

Przed Visual C++ 2010 ten przykład generuje następujące wyniki:

In MemoryBlock(size_t). length = 25.
In MemoryBlock(const MemoryBlock&). length = 25. Copying resource.
In ~MemoryBlock(). length = 25. Deleting resource.
In MemoryBlock(size_t). length = 75.
In MemoryBlock(const MemoryBlock&). length = 25. Copying resource.
In ~MemoryBlock(). length = 25. Deleting resource.
In MemoryBlock(const MemoryBlock&). length = 75. Copying resource.
In ~MemoryBlock(). length = 75. Deleting resource.
In MemoryBlock(size_t). length = 50.
In MemoryBlock(const MemoryBlock&). length = 50. Copying resource.
In MemoryBlock(const MemoryBlock&). length = 50. Copying resource.
In operator=(const MemoryBlock&). length = 75. Copying resource.
In operator=(const MemoryBlock&). length = 50. Copying resource.
In ~MemoryBlock(). length = 50. Deleting resource.
In ~MemoryBlock(). length = 50. Deleting resource.
In ~MemoryBlock(). length = 25. Deleting resource.
In ~MemoryBlock(). length = 50. Deleting resource.
In ~MemoryBlock(). length = 75. Deleting resource.

Wersja tego przykładu, który używa semantyki przenoszenia, jest bardziej wydajna niż wersja, która nie używa semantyki przenoszenia, ponieważ wykonuje mniejszą liczbę kopii, alokacji pamięci i operacji dezalokacji pamięci.

Stabilne programowanie

Aby zapobiec przeciekom zasobów, zawsze uwalniaj zasoby (takie jak pamięć, programy obsługi plików i gniazda) w operatorze przypisania przenoszenia.

Aby zapobiec nieodwracalnemu niszczeniu zasobów, prawidłowo obsługuj własny przydziału w operatorze przypisania przenoszenia.

Jeśli podasz zarówno konstruktora przenoszącego, jak i operator przypisywania przenoszenia dla swojej klasy, można wyeliminować nadmiarowy kod, pisząc konstruktor przenoszącego do wywoływania operatora przypisywania przenoszenia.Poniższy przykład ukazuje poprawioną wersję konstruktora przenoszącego, który wywołuje operator przypisania przenoszenia:

// Move constructor.
MemoryBlock(MemoryBlock&& other)
   : _data(NULL)
   , _length(0)
{
   *this = std::move(other);
}

Funkcja std::move zachowuje własność rvalue parametru other.

Zobacz też

Informacje

Deklarator odwołania do wartości R: &&

Inne zasoby

<utility> move

Udostępnij za pośrednictwem