最佳C++移动构造函数实现实践
Best C++ move constructor implementation practice
我想了解移动构造函数的实现。
我们都知道，如果我们需要在 C++ 中管理资源 class，我们需要实现五法则（C++ 编程）。
微软给我们举了个例子：https://msdn.microsoft.com/en-us/library/dd293665.aspx
这是更好的一个，它使用复制交换来避免代码重复：
Dynamically allocating an array of objects
// C++11
A(A&& src) noexcept
: mSize(0)
, mArray(NULL)
{
// Can we write src.swap(*this);
// or (*this).swap(src);
(*this) = std::move(src); // Implements in terms of assignment
}
在移动构造函数中，直接：
// Can we write src.swap(*this);
// or (*this).swap(src);
因为我觉得(*this) = std::move(src)有点复杂。因为如果我们不小心写成(*this) = src，它会调用普通的赋值运算符而不是移动赋值运算符
抛开这个问题，在微软的例子中，他们是这样写代码的：在move-assignment-operator中，是否需要检查自赋值？有可能发生吗？
// 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 = nullptr;
other._length = 0;
}
return *this;
}
一种方法是实现默认构造函数、复制构造函数和swap函数。
然后使用前三个实现移动构造函数、复制和移动赋值运算符。
例如：
struct X
{
X();
X(X const&);
void swap(X&) noexcept;
X(X&& b)
: X() // delegate to the default constructor
{
b.swap(*this);
}
// Note that this operator implements both copy and move assignments.
// It accepts its argument by value, which invokes the appropriate (copy or move) constructor.
X& operator=(X b) {
b.swap(*this);
return *this;
}
};
如果您一直在 C++98 中使用这个习惯用法，那么一旦您添加了移动构造函数，您就可以在不编写任何代码的情况下获得移动赋值。
In some cases this idiom may be not the most efficient。因为复制操作符总是先构造一个临时的，然后再与之交换。通过手动编码赋值运算符，可以获得更好的性能。如有疑问，请检查优化的程序集输出并使用分析器。
我也在网上寻找实现移动构造函数和移动赋值的最佳方法。有一些方法，但都不是完美的。
以下是我目前的发现。
这是一个 Test class 我用的例子：
class Test {
private:
std::string name_;
void* handle_ = nullptr;
public:
Test(std::string name)
: name_(std::move(name))
, handle_(malloc(128))
{
}
~Test()
{
if(handle_) free(handle_);
}
Test(Test&& other) noexcept;
Test& operator=(Test&& other) noexcept;
void swap(Test& v) noexcept
{
std::swap(this->handle_, v.handle_);
std::swap(this->name_, v.name_);
}
private:
friend void swap(Test& v1, Test& v2) noexcept
{
v1.swap(v2);
}
};
方法一：直截了当
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
if(handle_) free(handle_);
handle_ = std::exchange(other.handle_, nullptr);
name_ = std::move(other.name_);
return *this;
}
优点
- 最佳表现
缺点
- 移动构造函数和移动赋值中的代码重复
- 部分析构函数代码在移动赋值中重复
方法 #2：破坏 + 建造
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
this->~Test();
new (this) Test(std::move(other));
return *this;
}
优点
- 没有代码重复
- 在没有虚函数的情况下表现良好
缺点
- 虚拟方法 Table (VMT) 被初始化两次（如果 class 有虚拟函数）
- 不能在基地class中使用。基础 class 必须仅实现移动构造函数。
方法 #3：复制'n'交换
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
Test (std::move(other)).swap(*this);
return *this;
}
或复制和移动运算符二合一：
Test& Test::operator=(Test other) noexcept
{
swap(other, *this);
return *this;
}
优点
- 没有代码重复
缺点
- 创建了额外的对象
- 在
swap 函数内交换数据成员时创建了额外的小对象
- 交换函数中的某种代码重复
方法 4：通过移动赋值移动构造函数
这是你@Dongguo 在 MSDN 上找到的
Test::Test(Test&& other) noexcept
{
*this = std::move(other);
}
Test& Test::operator=(Test&& other) noexcept
{
if(handle_) free(handle_);
handle_ = std::exchange(other.handle_, nullptr);
name_ = std::move(other.name_);
return *this;
}
优点
- 没有代码重复
缺点
- 不适用于包含非默认可构造数据成员的 classes。
- 数据成员在移动构造函数中被初始化两次
链接
- [Wiki] - Move assignment operator
- [cppreference.com] - Move assignment operator
- [MSDN] - Move Constructors and Move Assignment Operators
- [Vollmann] - C++: More on Implementing Move Assignment
- [Herb Sutter] - Move, simply
更多答案
- Implementing Move Constructor by Calling Move Assignment Operator
- What is the copy-and-swap idiom?
我想了解移动构造函数的实现。 我们都知道，如果我们需要在 C++ 中管理资源 class，我们需要实现五法则（C++ 编程）。
微软给我们举了个例子：https://msdn.microsoft.com/en-us/library/dd293665.aspx
这是更好的一个，它使用复制交换来避免代码重复： Dynamically allocating an array of objects
// C++11
A(A&& src) noexcept
: mSize(0)
, mArray(NULL)
{
// Can we write src.swap(*this);
// or (*this).swap(src);
(*this) = std::move(src); // Implements in terms of assignment
}
在移动构造函数中，直接：
// Can we write src.swap(*this);
// or (*this).swap(src);
因为我觉得(*this) = std::move(src)有点复杂。因为如果我们不小心写成(*this) = src，它会调用普通的赋值运算符而不是移动赋值运算符
抛开这个问题，在微软的例子中，他们是这样写代码的：在move-assignment-operator中，是否需要检查自赋值？有可能发生吗？
// 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 = nullptr;
other._length = 0;
}
return *this;
}
一种方法是实现默认构造函数、复制构造函数和swap函数。
然后使用前三个实现移动构造函数、复制和移动赋值运算符。
例如：
struct X
{
X();
X(X const&);
void swap(X&) noexcept;
X(X&& b)
: X() // delegate to the default constructor
{
b.swap(*this);
}
// Note that this operator implements both copy and move assignments.
// It accepts its argument by value, which invokes the appropriate (copy or move) constructor.
X& operator=(X b) {
b.swap(*this);
return *this;
}
};
如果您一直在 C++98 中使用这个习惯用法，那么一旦您添加了移动构造函数，您就可以在不编写任何代码的情况下获得移动赋值。
In some cases this idiom may be not the most efficient。因为复制操作符总是先构造一个临时的，然后再与之交换。通过手动编码赋值运算符，可以获得更好的性能。如有疑问，请检查优化的程序集输出并使用分析器。
我也在网上寻找实现移动构造函数和移动赋值的最佳方法。有一些方法，但都不是完美的。
以下是我目前的发现。
这是一个 Test class 我用的例子：
class Test {
private:
std::string name_;
void* handle_ = nullptr;
public:
Test(std::string name)
: name_(std::move(name))
, handle_(malloc(128))
{
}
~Test()
{
if(handle_) free(handle_);
}
Test(Test&& other) noexcept;
Test& operator=(Test&& other) noexcept;
void swap(Test& v) noexcept
{
std::swap(this->handle_, v.handle_);
std::swap(this->name_, v.name_);
}
private:
friend void swap(Test& v1, Test& v2) noexcept
{
v1.swap(v2);
}
};
方法一：直截了当
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
if(handle_) free(handle_);
handle_ = std::exchange(other.handle_, nullptr);
name_ = std::move(other.name_);
return *this;
}
优点
- 最佳表现
缺点
- 移动构造函数和移动赋值中的代码重复
- 部分析构函数代码在移动赋值中重复
方法 #2：破坏 + 建造
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
this->~Test();
new (this) Test(std::move(other));
return *this;
}
优点
- 没有代码重复
- 在没有虚函数的情况下表现良好
缺点
- 虚拟方法 Table (VMT) 被初始化两次（如果 class 有虚拟函数）
- 不能在基地class中使用。基础 class 必须仅实现移动构造函数。
方法 #3：复制'n'交换
Test::Test(Test&& other) noexcept
: handle_(std::exchange(other.handle_, nullptr))
, name_(std::move(other.name_))
{
}
Test& Test::operator=(Test&& other) noexcept
{
Test (std::move(other)).swap(*this);
return *this;
}
或复制和移动运算符二合一：
Test& Test::operator=(Test other) noexcept
{
swap(other, *this);
return *this;
}
优点
- 没有代码重复
缺点
- 创建了额外的对象
- 在
swap函数内交换数据成员时创建了额外的小对象 - 交换函数中的某种代码重复
方法 4：通过移动赋值移动构造函数
这是你@Dongguo 在 MSDN 上找到的
Test::Test(Test&& other) noexcept
{
*this = std::move(other);
}
Test& Test::operator=(Test&& other) noexcept
{
if(handle_) free(handle_);
handle_ = std::exchange(other.handle_, nullptr);
name_ = std::move(other.name_);
return *this;
}
优点
- 没有代码重复
缺点
- 不适用于包含非默认可构造数据成员的 classes。
- 数据成员在移动构造函数中被初始化两次
链接
- [Wiki] - Move assignment operator
- [cppreference.com] - Move assignment operator
- [MSDN] - Move Constructors and Move Assignment Operators
- [Vollmann] - C++: More on Implementing Move Assignment
- [Herb Sutter] - Move, simply
更多答案
- Implementing Move Constructor by Calling Move Assignment Operator
- What is the copy-and-swap idiom?