`*this` 可以是 `move()`d 吗？

Question

我想定义一个用于编组数据的类；编组完成后，我想 move 将编组后的数据从其中取出，这可能会使编组对象无效。

我相信这可以通过下面的static 函数extractData 实现：

class Marshaller
{
  public:
    static DataType extractData(Marshaller&& marshaller)
    {
      return std::move(marshaller.data);
    }
  private:
    DataType data;
}

虽然这样调用有点不方便：

Marshaller marshaller;
// ... do some marshalling...
DataType marshalled_data{Marshaller::extractData(std::move(marshaller))};

那么我可以用成员函数包装它吗？

DataType Marshaller::toDataType()
{
  return Marshaller::extractData(std::move(*this));
}

当然，这会被调用：

DataType marshalled_data{marshaller.toDataType()};

...对我来说，这看起来好多了。但是std::move(*this) 的事情看起来非常可疑。在调用toDataType() 的上下文中，marshaller 不能再次使用，但我认为编译器无法知道：函数的主体可能在调用者的编译单元之外，所以没有什么可做的表示marshaller 已应用move()。

这是未定义的行为吗？完全没问题吗？或者介于两者之间？有没有更好的方法来实现相同的目标，最好不使用宏或要求调用者明确地movemarshaller？

编辑： 使用 G++ 和 Clang++，我发现我不仅可以编译上述用例，而且我实际上可以继续通过编组器对基础数据进行修改，然后使用toDataType 函数重新提取修改后的数据。我还发现marshalled_data中的already-extracted数据继续被marshaller改变，说明marshalled_data是marshaller和调用上下文共享的，所以我怀疑这里有内存泄漏或未定义的行为（来自双重删除）。

编辑 2： 如果我在 DataType 的析构函数中放入 print 语句，当调用者离开作用域时，它会出现 两次。如果我在 DataType 中包含一个包含数组的数据成员，并带有相应的 new[] 和 delete[]，我会收到 glibc“双重释放或损坏”错误。所以我不确定这如何是安全的，尽管有几个答案说它在技术上是允许的。一个完整的答案应该解释正确使用这种技术与非平凡的DataType 类需要什么。

编辑 3： 这已经足够我打开 another question 来解决我剩下的问题了。

Answer 1

根据标准，move-from 对象仍然有效，尽管不能保证其状态，因此从*this 移动似乎是完全有效的。代码的用户是否会感到困惑完全是另一个问题。

这听起来像你的真实意图是将元帅的破坏与数据的提取联系起来。您是否考虑过在一个表达式中完成所有编组并让临时人员为您处理事情？

class Marshaller
{
  public:
    Marshaller& operator()(input_data data) { marshall(data); return *this; }
    DataType operator()() { return std::move(data_); }
  private:
    DataType data_;
}

DataType my_result = Marshaller()(data1)(data2)(data3)();

Answer 2

我会避免从*this 移动，但如果你这样做，至少你应该在函数中添加右值引用限定符：

DataType Marshaller::toDataType() &&
{
    return Marshaller::extractData(std::move(*this));
}

这样，用户将不得不这样调用它：

// explicit move, so the user is aware that the marshaller is no longer usable
Marshaller marshaller;
DataType marshalled_data{std::move(marshaller).toDataType()};

// or it can be called for a temporary marshaller returned from some function
Marshaller getMarshaller() {...}
DataType marshalled_data{getMarshaller().toDataType()};

Answer 3

调用move(*this) 本身并没有什么不安全的地方。 move 本质上只是一个被调用函数的提示，它可能会窃取对象的内部结构。在类型系统中，这个承诺是通过&& 引用来表达的。

这与破坏无关。 move 不执行任何类型的破坏 - 如前所述，它只是使我们能够调用带有 && 参数的函数。接收移动对象的函数（在这种情况下为extractData）也不会进行任何破坏。实际上，它需要让对象处于“有效但未指定的状态”。本质上，这意味着必须能够以正常方式销毁对象（通过delete 或超出范围，具体取决于对象的创建方式）。

所以 - 如果你的 extractData 做了它应该做的事情，并且让对象处于允许它稍后被破坏的状态 - 就编译器而言，没有任何未定义或危险的事情发生。当然，代码的 users 可能会出现问题，因为对象被移出并不完全明显（以后可能不会包含任何数据）。通过更改函数名称，这可能会更清楚一点。或者（作为另一个答案建议）&&-qualifying 整个方法。

Answer 4

我认为您不应该从*this 移出，而应从其data 字段移出。由于这显然会使Marshaller 对象处于有效但不可用的状态，因此执行此操作的成员函数本身应该在其隐式*this 参数上具有右值引用限定符。

class Marshaller
{
public:
  ...
  DataType Marshaller::unwrap() &&   { return std::move(data); }

  ...
private:
  DataType data;
};

调用它，如果m 是Marshaller 变量，则为std::move(m).unwrap()。不需要任何静态成员来完成此操作。

Answer 5

您写道，您希望同时销毁 Marshaller 并从中删除数据。我真的不担心尝试同时做这些事情，只需先将数据移出然后销毁 Marshaller 对象。有很多方法可以不用考虑太多就摆脱 Marshaller，也许智能指针对您有意义？

重构的一个选项是为 DataType 提供一个构造函数，该构造函数采用 Marshaller 并将数据移出（'friend' 关键字将允许您这样做，因为 DataType 将能够访问该私有 'data'变量）。

    //add this line to the Marshaller
    friend class DataType;

struct DataType
{
    DataType(Marshaller& marshaller) {
             buffer = marshaller.data.buffer;
        }

    private: 
        Type_of_buffer buffer;//buffer still needs to know how to have data moved into it
}

你也可以给它一个赋值运算符来做同样的事情（我认为这会起作用：

DataType& operator=(Marshaller&& marshaller) {
     this.buffer = std::move(marshaller.data.buffer);
     return *this;
}

)

我会避免在 *this 上使用 move ，因为即使它是正确的也会让人们失望。看起来基于堆栈的缓冲区容器可能会给您带来麻烦。

您似乎担心在编译单元之外再次调用 Marshaller。如果您有密集的并行代码并且在编组器上玩得又快又松，或者您正在随意复制指向编组器的指针，那么我认为您的担心是有道理的。否则，请查看 Marshaller 是如何移动的，并确保您的代码结构具有良好的对象生命周期（尽可能使用对象引用）。您也可以向 marshaller 添加一个成员标志，说明“数据”是否已被移动，如果有人在它离开后尝试访问它，则会引发错误（如果您是并行的，请务必锁定）。我只会将此作为最后的手段或快速修复，因为它看起来不正确，您的共同开发人员会想知道发生了什么。

如果你有时间，我有一些事要挑：

• 您的 extractData 方法缺少静态关键字
• 在 DataType 声明行中混合使用括号和括号