Postupy: Zápis konstruktoru přesunu

Toto téma popisuje, jak zapisovat konstruktor přesunutí a operátor přiřazení přesunutí pro třídu jazyka C++.Konstruktor přesunu umožňuje implementovat sémantiku přesunu, což může výrazně zlepšit výkon aplikací.Další informace o sémantice pohybu naleznete v tématu Deklarátor odkazu hodnoty R: &&.

Toto téma staví na následující třídě jazyka C++, MemoryBlock, která spravuje vyrovnávací paměť.

// 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.
};

Následující postupy popisují, jak zapsat konstruktor přesunu a operátor přiřazení přesunu pro vzorovou třídu C++.

Vytvoření konstruktoru přesunu pro třídu jazyka C++

1. Definujte metodu prázdného konstruktoru, který bere hodnotu rvalue na typ třídy jako svůj parametr, jak je ukázáno v následujícím příkladu:

   MemoryBlock(MemoryBlock&& other)
      : _data(NULL)
      , _length(0)
   {
   }
   

2. V konstruktoru přesunu přiřaďte datové členy třídy ze zdrojového objektu do objektu, který je vytvářen:

   _data = other._data;
   _length = other._length;
   

3. Přiřaďte datové členy zdrojového objektu výchozím hodnotám.Tím se destruktoru zabrání v uvolnění prostředků (například paměti) několikrát za sebou:

   other._data = NULL;
   other._length = 0;
   

Vytvoření operátora přiřazení přesunu pro třídu jazyka C++

1. Definujte prázdný operátor přiřazení, který bere odkaz rvalue pro typ třídy jako svůj parametr a vrátí odkaz na typ třídy, jak je ukázáno v následujícím příkladu:

   MemoryBlock& operator=(MemoryBlock&& other)
   {
   }
   

2. U operátoru přiřazení přesunu přidejte podmíněný příkaz, který neprovádí operaci, pokud se pokusíte přiřadit objekt sám sobě.

   if (this != &other)
   {
   }
   

3. V podmíněném příkazu uvolněte veškeré prostředky (jako je paměť) z objektu, ke kterému jsou přiřazeny.

   V následujícím příkladu se uvolní člen _data z objektu, který je přiřazen k:

   // Free the existing resource.
   delete[] _data;
   

   Postupujte podle kroků 2 a 3 v prvním postupu pro přenos datových členů ze zdrojového objektu na objekt, který je konstruován:

   // 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;
   

4. Vrací odkaz na aktuální objekt, jak je znázorněno v následujícím příkladu:

   return *this;
   

Příklad

Následující příklad ukazuje kompletní konstruktor přesunu a operátor přiřazení přesunu pro třídu 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;
}

Následující příklad ukazuje, jak sémantika přesunu může zlepšit výkon aplikací.Příklad přidá dva prvky do vektorového objektu a poté vloží nový prvek mezi dva existující prvky.Ve Visual C++ 2010 třída vector používá sémantiky přesunutí pro efektivní provádění operace vložení přesunutím elementů vektoru místo jejich kopírování.

// 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));
}

Tento příklad vytvoří následující výstup:

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.

Před Visual C++ 2010 tento příklad vytvoří následující výstup:

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.

Verze tohoto příkladu, která používá sémantiku přesunutí, je efektivnější než verze, která nepoužívá sémantiku přesunutí, protože vykonává méně operací kopírování, přidělení paměti a zrušení přidělení paměti.

Robustní programování

Chcete-li zabránit nedostatku prostředků, vždy uvolněte prostředky (například paměť popisovače souborů a sokety) v operátoru přiřazení přesunutí.

Chcete-li zabránit neobnovitelnému zničení prostředků, správně zpracovávejte vlastní přiřazení v operátoru přiřazení přesunutí.

Pokud zadáte pro třídu konstruktor přesunutí a operátor přiřazení přesunutí, můžete vyloučit redundantní kód zápisem konstruktoru přesunutí, aby volal operátor přiřazení přesunutí.Následující příklad ukazuje přepracovanou verzi konstruktoru přesunu, který volá operátor přiřazení přesunu:

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

Funkce std::move zachová vlastnost rvalue parametru other.

Viz také

Referenční dokumentace

Deklarátor odkazu hodnoty R: &&

Další zdroje

<utility> move