关于移动赋值和移动构造你可能需要注意的地方

[MrShinshi]

此文为对 #206 的补充，先说结论：

当实现 移动构造函数 或 移动赋值函数 时，你应该优先选择使用 std::swap 而不是直接对成员使用 m = std::move(right.m);

当然部分朋友认为这是常识，但这确实是实际开发中可能遇到的错误之一。

我们在成员中持有指针时， 会直接在移动实现中选择 ptr = right.ptr， 这样往往会埋下一个暗雷 ：

struct A
{
	A() :ptr(new char) {}
	~A() { delete ptr; }

	// 我就返回 void，卢瑟要起义~~
	// 好孩子不要学，好孩子不要学~~
	void operator =(A&& right) noexcept 
	{ 
		ptr = right.ptr; 
		right.ptr = nullptr;
	}
private:
	char* ptr{};
};

上面的代码就是一个错误的示范，尽管已经通过 right.ptr = nullptr 进行置空避免了资源被意外释放，但仍旧造成了内存泄漏。

移动构造函数 或 移动赋值函数 的目的是为了直接 转移右值所持有资源的所有权，而非拷贝。

这里有个不易察觉的点，转移右值所持有资源的所有权 并不意味着标准保证用户不需要对 左值原本持有的资源 负责。

可以选择手动追加一句 delete ptr; 但这样做无疑是繁琐的，尤其是类似的成员存在复数个的情况。应优先选择使用 std::swap ，把 左值 的旧资源 托管给 右值 的析构函数进行释放，语义也更加明确。

	// use std::move
	void operator =(A&& right) noexcept 
	{  
		std::swap(ptr, right.ptr);
	}

	// without use std::move
	void operator =(A&& right) noexcept 
	{
		delete ptr;
		ptr = right.ptr; 
		right.ptr = nullptr;
	}

事实上，实际开发中，你需要 尽可能少的主动控制过程 ，转而根据需求合理选择封装好的、安全的接口。越是做没必要的工作，你就越是要承担更多原本不必要的责任。

一个相似的例子是，同事在代码中大量使用了C风格的内存申请与size记录且并未进行合理封装（实际情况要比我描述的抽象得多），然后每次重新分配或使用内存就不得不手动确保自己每一处代码正确的同时更新了 ptr 和 size，你能想到的，他因此遇到了许多原本可以轻松避免的问题。

移动的实现也是如此，你往往不需要手动的释放左值原有的资源，使用 std::swap 就足够了。

[MrShinshi]

一楼国王祭天

[Mq-b]

我觉得你不如顺便放点 std::unique_ptr、std::shared_ptr 的移动赋值的源码，msvc STL、libstdc++、libc++ 都行。

[MrShinshi]

msvc STL example：

std::unique_ptr::operator=(&&)

template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
_CONSTEXPR23 unique_ptr& operator=(unique_ptr&& _Right) noexcept {
    reset(_Right.release());
    _Mypair._Get_first() = _STD forward<_Dx>(_Right._Mypair._Get_first());
    return *this;
}

std::shared_ptr::operator=(&&)

shared_ptr& operator=(shared_ptr&& _Right) noexcept { // take resource from _Right
    shared_ptr(_STD move(_Right)).swap(*this);
    return *this;
}

[MrShinshi]

上面是 msvc 中 移动赋值 的例子，一般而言移动构造的例子应参考 std::string std::vector 这类 RAII 容器，但翻了几个都实现得比较抽象，不如上文中的代码直观，因此就不放了。

[MrShinshi]

@Mq-b 这么有价值的坑不水个视频？

[Mq-b]

没兴趣

[MrShinshi]

🤡国王是没兴趣,我是没才能

[frederick-vs-ja]

作为和标准库有较深入接触的人，我得说楼主的策略在标准库中几乎没有得到采用。标准库实现中像 shared_ptr 中用 swap 实现移动赋值的情况很少， shared_ptr 的做法还是标准钦定的（[util.smartptr.shared.assign]）。

（只）推荐 std::swap 本身在我看来也是不完善的，有可能 std::swap 就不是用户所用的库的所期待的 swap 重载（见 C++ 具名要求：可交换 (Swappable) ）。更好的做法是用 std::ranges::swap。

如果要用现成的函数，我的推荐是用 std::exchange。

struct A {
	A() = default; // 如果允许对象的状态，为什么不让默认构造函数创建它？
	~A() { delete ptr; }

	A(A&& right) noexcept :
		ptr(std::exchange(right.ptr, nullptr /* 或者空列表 {} */})) {}
	A& operator=(A&& right) noexcept // 返回 void 小心 std::assignable_from 找你麻烦。
	{ 
		delete std::exchange(ptr, std::exchange(right.ptr, nullptr)); // 无论 *this 和 right 是否为同一对象都 OK！
		return *this;
	}
private:
	char* ptr{};
};

这个做法的好处是能轻松地处理自移动赋值。

通常情况下 *this 和 right 是两个不同的对象，此时流程是

1. 先把 right.ptr 设为 nullptr，并获取其旧值；
2. 用刚才获取的 right.ptr 旧值赋值给 this->ptr，并且得到期待的用以释放的 this->ptr 旧值；
3. 把 this->ptr 旧值删除掉。

显然没有问题。

然而，如果 *this 和 right 实际上是同一个对象，那么操作是……

1. 先把 this->ptr 设为 nullptr，并获取其旧值；
2. 用刚才获取的 this->ptr 旧值赋值再次给 this->ptr，并且得到刚才设进去的空指针值；
3. 把空指针值删除掉。

同样没有问题！而且保证最后 *this 维持原值，不会意外释放内存。

[Mq-b]

“多数场景下应在移动后立即销毁”，显然不对，标准库一堆的设施，移动构造移动赋值，都是单纯转移资源所有权，不会删除，比如 std::vector、std::string、std::shared_ptr

这是有问题的。目前实现中 std::vector 和 std::basic_string 在移动赋值时如果能夺取资源，都会把原先的内容解分配掉。

举个例子？我之前看的都是直接转移资源。

[frederick-vs-ja]

“多数场景下应在移动后立即销毁”，显然不对，标准库一堆的设施，移动构造移动赋值，都是单纯转移资源所有权，不会删除，比如 std::vector、std::string、std::shared_ptr

这是有问题的。目前实现中 std::vector 和 std::basic_string 在移动赋值时如果能夺取资源，都会把原先的内容解分配掉。

举个例子？我之前看的都是直接转移资源。

譬如说 MSVC STL 的 vector 移动赋值运算符，在能转移资源时都会先清除掉旧的。
https://github.com/microsoft/STL/blob/32e65ac3e54a7150202cc9b3cc4de7330d58d24e/stl/inc/vector#L745

[Mq-b]

“多数场景下应在移动后立即销毁”，显然不对，标准库一堆的设施，移动构造移动赋值，都是单纯转移资源所有权，不会删除，比如 std::vector、std::string、std::shared_ptr

这是有问题的。目前实现中 std::vector 和 std::basic_string 在移动赋值时如果能夺取资源，都会把原先的内容解分配掉。

“多数场景下应在移动后立即销毁”，显然不对，标准库一堆的设施，移动构造移动赋值，都是单纯转移资源所有权，不会删除，比如 std::vector、std::string、std::shared_ptr

这是有问题的。目前实现中 std::vector 和 std::basic_string 在移动赋值时如果能夺取资源，都会把原先的内容解分配掉。

举个例子？我之前看的都是直接转移资源。

譬如说 MSVC STL 的 vector 移动赋值运算符，在能转移资源时都会先清除掉旧的。 https://github.com/microsoft/STL/blob/32e65ac3e54a7150202cc9b3cc4de7330d58d24e/stl/inc/vector#L745

#include <iostream>
#include <vector>

struct X{
    ~X() { puts("~X"); }
};

int main(){
    std::vector<X>v{ {} };
    std::cout << &v[0] << '\n';
    std::vector<X>v2{};
    v2 = std::move(v);
    std::cout << &v2[0] << '\n';
}

我测试这段代码在 gcc、msvc、clang ，v 和 v2 打印的地址都是相同的，这是内存复用了？

[frederick-vs-ja]

移动赋值后 v2 夺取了 v 原先持有的内存资源。如果 v2 本身之前持有内存资源（这个例子没有），那么在目前实现中旧的内存资源会被释放掉。

[Mq-b]

那肯定没的说，如果原先就持有了资源，肯定没办法直接转移个指针。