如何让一个类被其他类移动？

Question

假设我有一个 RAII 课程，例如 vector：

class vector{
   double* data_;
   int size_;
public:
   explicit vector(int size = 0) : data_{new double[size]}, size_{size}{}
   vector(vector const& other) : data_{new double[other.size_]}, size_{other.size_}{}
   int size() const{return size_;}
   double const* data() const{return data_;}
   double* data(){return data_;} // optional but common
   ~vector(){if(size_) delete[] double;}
}

如果我想让类可移动，我可以添加一个移动构造函数。

   vector(vector&& other) : size_{other.size_}, data_{other.data_}{other.size_ = 0;}

到目前为止，模数错别字和迂腐的 cmets，仅此而已。

但是，我想让与我的vector 无关的其他 类移动该类。 我知道这基本上需要类似于移动构造函数的代码，但在一个独立的类中。

class SuperVector{
   double* data_begin_;
   double* data_end_; // I don't use size to show having two independent implementations
   std::string super = "super";
   SuperVector(vector&& v) ... {...} // what here? what needs to change in `vector`?
};

我几乎可以肯定，无论SuperVector 代码如何，vector 都需要以某种方式进行更改以允许这样做。

问题是是否有一个常用的协议来允许这些不相关类的可移动性。或者这是尚未考虑的事情。 （我想偶尔人们会想从std::vector 转移到一个不相关的类）。

---

前期工作：

我能想到的解决方案是：

1. 让SuperVector成为vector的朋友，然后简单地实现“进入”的移动

      SuperVector(vector&& v) : data_begin_{v.data()}, data_end_{v.data() + v.size()}{v.size_ = 0;}
   

   这个问题是友谊增加了很多耦合，它不是一个通用的解决方案。

2. 提供对向量内部表示的更多访问权限（特别是使其可分配）。

      int& vector::size(){return size_;}
   

      SuperVector(vector&& v) : data_begin_{v.data()}, data_end_{v.data() + v.size()}{v.size() = 0;}
   

   这真的很糟糕，因为任何人都可以更改size、破坏不变量等。

   现在是更复杂和重要的选项。

3. 类似 2) 但添加了特殊功能：

   class vector{...
      [[nodiscard]] // false sense of security
      double* moved_data()&&{ // for lack of a better name (simply data()&&?)
         size_ = 0;
         return data_;
      }
   ...}
   

   并将其用作

      SuperVector(vector&& v){ // or some variation of this
        data_end_ = v.data() + v.size()}; 
        data_begin_ = std::move(v).moved_data();
      }
   

   这样做的缺点是vector需要修改，这是意料之中的。 但是，任何人都可以调用moved_data 并使vector 无效，这似乎很危险。 此外，这取决于[[nodiscard]]，并且可能会从不相关的类中产生内存泄漏。 最糟糕的vector 似乎“过早地”处于从状态移动的状态，远在对象真正从（客户端）其他类中移动之前。

   最后，

4. 也许我缺少的是某种新的智能指针，它可以延迟移动到以后的时间。 我在这里称它为move_ptr。

   template<class CustomMover>
   class move_ptr{ // or transfer_ptr
      double* ptr_;
      CustomMover mover_;
   public:
      move_ptr(double* ptr, CustomMover mover) : ptr_{ptr}, mover_{std::move(mover)}{}
      // probably movable too.
      [[nodiscard]] operator double*(){ // protect against twice move
         if(ptr_) mover_();
         auto ret = ptr_; ptr_ = nullptr; return ret;
      }
   //   ~move_ptr(){} // if nobody took care, that is ok, nothing happens.
   }
   

   class vector{...
      auto moved_data()&&{ // for lack of a better name (or simply data()&&?)
         auto custom_mover = [&size_]{size_ = 0;};
         return move_ptr<decltype(custom_mover)>{data_, custom_mover_};
      }
   ...}
   

   （其他可能的名称是move()& 或mdata()& 或mdata()&& 或data()&&。）

   请注意，移动的副作用是由智能指针携带的。

   并将其用作

      SuperVector(vector&& v){ // or some variation of this
        data_end_ = v.data() + v.size()}; 
        data_begin_ = std::move(v).moved_data(); // this will set size to zero
      }
   

   我确信这个简单的代码没有考虑到一些极端情况，但我希望主要思想是明确的。

   欢迎修复。

   这个智能指针有意义吗，还是已经在某个地方实现了类似“移动管理器指针”的东西？

   我看到这类似于std::unique_ptr，除了移动是由复制的智能指针实现的，而且自定义操作仅在赋值时发生（到常规指针）。

   也许std::unique_ptr 可以达到相同的效果，但我不知道如何。

这是这个更抽象问题的具体应用：Exact correspondence between r-value references and pointers?

Answer 1

您已经了解了所有可能性，您的问题的直接答案是不存在通用协议。

这个答案回顾了 std::lib 中允许将所有权转移到不相关类型的几个地方。

unique_ptr

auto p = up.release();

unique_ptrup 已放弃其资源的所有权，现在由客户端负责。

unique_lock

auto m = ul.release();

unique_lockul 已放弃对其互斥锁的锁定状态的所有权，现在由客户端负责。

关联容器和无序容器

extract 成员函数查找单个元素（通过键或迭代器）并在名为container::node_type 的类似智能指针的对象中释放单个节点的所有权。这个“智能指针”有一个分配器的副本，因此它知道如何自毁。它还为客户端提供了对包含元素的非常量访问。当元素的关键部分归容器所有时，只有 const 访问可用。

Answer 2

基本上不可能有一个通用的解决方案。从根本上移出一个值意味着您需要了解该值类型的实现细节，尤其是它如何管理内存。

因此，您需要以一种或另一种方式（通过友谊，或者更公开的接口）发布这些实现细节，这通常是不可取的。无论哪种方式，您都会在类型之间获得紧密耦合，这是无法避免的。

即使可能，我也不认为这会像您想象的那样普遍有用。