Konstruktory a operátory přiřazení pro přesunutí (C++)
Toto téma popisuje, jak napsat konstruktor přesunutí a operátor přiřazení přesunutí pro třídu C++. Konstruktor přesunutí umožňuje přesun prostředků vlastněných objektem rvalue do lvalue bez kopírování. Další informace o sémantice přesunutí naleznete v tématu Referenční deklarátor Rvalue: &>.
Toto téma vychází z následující třídy 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 != nullptr)
{
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 napsat konstruktor move a operátor přiřazení přesunutí pro ukázkovou třídu C++.
Vytvoření konstruktoru move pro třídu C++
Definujte prázdnou metodu konstruktoru, která přebírá odkaz rvalue na typ třídy jako jeho parametr, jak je znázorněno v následujícím příkladu:
MemoryBlock(MemoryBlock&& other) : _data(nullptr) , _length(0) { }
V konstruktoru přesunutí přiřaďte datové členy třídy ze zdrojového objektu k objektu, který je vytvořen:
_data = other._data; _length = other._length;
Přiřaďte datové členy zdrojového objektu k výchozím hodnotám. Tím zabráníte destruktoru uvolnit prostředky (například paměť) vícekrát:
other._data = nullptr; other._length = 0;
Vytvoření operátoru přiřazení přesunutí pro třídu C++
Definujte prázdný operátor přiřazení, který přebírá odkaz rvalue na typ třídy jako jeho parametr a vrací odkaz na typ třídy, jak je znázorněno v následujícím příkladu:
MemoryBlock& operator=(MemoryBlock&& other) { }
V operátoru přiřazení přesunutí přidejte podmíněný příkaz, který neprovede žádnou operaci, pokud se pokusíte přiřadit objekt sám sobě.
if (this != &other) { }
V podmíněném příkazu uvolněte všechny prostředky (například paměť) z objektu, ke kterému je přiřazen.
Následující příklad uvolní
_data
člena z objektu, ke kterému je přiřazen:// Free the existing resource. delete[] _data;
Podle kroků 2 a 3 v prvním postupu přeneste datové členy ze zdrojového objektu do vytvořeného objektu:
// 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 = nullptr; other._length = 0;
Vrátí odkaz na aktuální objekt, jak je znázorněno v následujícím příkladu:
return *this;
Příklad: Dokončení konstruktoru přesunutí a operátoru přiřazení
Následující příklad ukazuje kompletní konstruktor přesunutí a operátor MemoryBlock
přiřazení pro třídu:
// Move constructor.
MemoryBlock(MemoryBlock&& other) noexcept
: _data(nullptr)
, _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 = nullptr;
other._length = 0;
}
// Move assignment operator.
MemoryBlock& operator=(MemoryBlock&& other) noexcept
{
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 = nullptr;
other._length = 0;
}
return *this;
}
Příklad použití sémantiky přesunutí ke zlepšení výkonu
Následující příklad ukazuje, jak může sémantika přesunutí zlepšit výkon vašich aplikací. Příklad přidá dva prvky do vektorového objektu a potom vloží nový prvek mezi dva existující prvky. Třída vector
používá sémantiku přesunutí k efektivnímu provádění operace vložení přesunutím prvků 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 = 75. Moving resource.
In MemoryBlock(MemoryBlock&&). length = 25. Moving resource.
In ~MemoryBlock(). length = 0.
In ~MemoryBlock(). length = 0.
In MemoryBlock(size_t). length = 50.
In MemoryBlock(MemoryBlock&&). length = 50. Moving resource.
In MemoryBlock(MemoryBlock&&). length = 25. Moving resource.
In MemoryBlock(MemoryBlock&&). length = 75. Moving resource.
In ~MemoryBlock(). length = 0.
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 sadou Visual Studio 2010 tento příklad vytvořil 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 provádí méně operací kopírování, přidělení paměti a uvolnění paměti.
Robustní programování
Aby se zabránilo nevracení prostředků, vždy volné prostředky (například paměť, popisovače souborů a sokety) v operátoru přiřazení přesunutí.
Chcete-li zabránit neobnovitelné zničení prostředků, správně zpracovat přiřazení sebe v operátoru přiřazení přesunutí.
Pokud pro třídu zadáte konstruktor přesunutí i operátor přiřazení přesunutí, můžete nadbytečný kód odstranit napsáním konstruktoru přesunutí, který zavolá operátor přiřazení přesunutí. Následující příklad ukazuje revidovanou verzi konstruktoru move, která volá operátor přiřazení přesunutí:
// Move constructor.
MemoryBlock(MemoryBlock&& other) noexcept
: _data(nullptr)
, _length(0)
{
*this = std::move(other);
}
Funkce std::move převede lvalue other
na hodnotu rvalue.
Viz také
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro