我可以在 std::move 之后重新使用像 std::vector 这样的复杂类吗？

Question

我正在创建一个游戏，并尝试学习移动语义/r 值引用。

我有一个类，每帧将Event 添加到vector 中。

60 帧后，我想将所有累积的事件移动到一个新类中（称为Step），该类将存储在另一个vector 中。

我想重复这个过程，所以在移动Event 向量后，它应该重置为空。

#include <vector>

class Event
{
    ...
}

class Step
{
    std::vector<Event> Events;

    Step(std::vector<Event>&& InEvents) : Events {InEvents} {}
}

class EventAccumulator
{
    std::vector<Event> Events;
    std::vector<Step> Steps;

    void Update(int FrameCount)
    {
        Events.push_back(Event());

        if (FrameCount % 60 == 0)
        {
            // Move accumulated events into a new Step.
            Step NewStep = Step(std::move(Events));
            Steps.push_back(NewStep);

            // Reset Events so that we can accumulate future events.
            Events = std::vector<Event>();
        }
    }
}

// Game Loop
int GlobalFrameCount = 0;
EventAccumulator eventAccumulator{};
while (true)
{
    eventAccumulator.Update(GlobalFrameCount++);
}

据我了解，Step NewStep = Step(std::move(Events)); 行将“给予”Events 到 NewStep（即不复制向量）。如果我在这方面错了，请纠正我。

我希望Events = std::vector(); 行导致EventAccumulator.Events 被重置为空向量，但我不希望NewStep.Events 被重置。

我的问题是，这段代码会做我想要的吗？

此外，您如何判断这是否适用于所有复杂的类，例如std::vector？我认为这是由类的赋值运算符重载决定的，但我对此感到困惑。

Answer 1

您的代码始终复制Events 向量，因此Events = std::vector(); 将简单地删除复制的元素。

为什么它是复制而不是移动？我们来看看Step的构造函数：

//                         that's a copy -----v
Step(std::vector<Event>&& InEvents) : Events {InEvents} {}

确实，表达式(InEvents) 是一个左值，因为它有一个名称。您必须使用 std::move 将其转换为右值：

Step(std::vector<Event>&& InEvents) : Events {std::move(InEvents)} {}

当通过&& 获取参数时，请记住它是一个可能移动，因为它只是一个引用，就像任何其他引用一样，您必须明确地移动它。

---

此行无法编译：

Events = std::vector();

也许你的意思是这样的：

Events = {};

这确实可以让您重用您的矢量。它将以导致确定状态的方式重置。

我希望Events = std::vector(); 行导致EventAccumulator.Events 被重置为空向量，但我不希望NewStep.Events 被重置。

我的问题是，这段代码会做我想要的吗？

C++ 具有值语义。除非NewStep 包含std::vector<Event>&，否则您不能影响其他地方的变量。您还可以在NewStep 中移动构造向量。这应该告诉你一些事情：你构建了一个新的向量。无论您如何改变旧向量，它都不会影响不同的向量。如果您更正 Step 构造函数，此代码将执行您想要的操作。

---

请记住，如果您想避免多次分配，您必须像这样调用reserve：

Events.reserve(60);

---

正如我在 cmets 中添加的那样，构造函数是移动语义的一种特殊情况：按值获取并移动它会增加很少的成本，而且很可能会被省略。这就是我的意思：

Step(std::vector<Event> InEvents) : Events {std::move(InEvents)} {}

如果你通过副本，那么它将复制到InEvents并移动它。如果你通过move传递，它会调用move构造函数两次，没有复制。

由于调用移动构造函数的成本可以忽略不计，它使您免于编写重载。

它只适用于构造函数，因为我们无法重用容量。这不适用于赋值或 setter 函数。