如何将不同的类存储在一个向量中？

Question

所以我有一个包含游戏所有对象的向量；诸如玩家对象、敌人对象、墙壁等...向量中的所有事物都是Framework 的子对象，所以我创建了向量类型Framework，因为这对它们来说是最接近通用数据类型的事物。

问题在于它没有从它存储的对象中运行被覆盖的函数。所以我用谷歌搜索，显然我是通过将它们存储为Framework 来进行对象切片的。那么我的问题是，如何将所有这些对象存储在一个列表中？

仅供参考，这是调用应该被覆盖的函数的地方。

for (vector<Framework>::iterator num = gameObjects.begin(); num != gameObjects.end(); ++num)
{
    //The current thing
    Framework currentObject = *num;
    currentObject.frameEvent();
    currentObject.frameEndEvent();
    currentObject.drawEvent();
}

提前致谢。

Answer 1

您必须存储指针 (Framework*) 或 std::shared_ptr< Framework > (可能是 std::unique_ptr< Framework >) 实例。这允许使用虚拟调用和late binding - 这意味着当您引用您的对象时，将在运行时确定要调用的正确函数。不要忘记让你的函数virtual

然后，你的代码（以类似的方式）

for (vector< Framework* >::iterator num = gameObjects.begin(); num != gameObjects.end(); ++num)
{
  Framework* currentObject = *num;
  currentObject->frameEvent();
  currentObject->frameEndEvent();
  currentObject->DrawEvent();
}

但是，我会推荐这样的东西（需要 c++11）

vector< std::unique_ptr< Framework > > gameObjects;

...

for (auto & currentObject : gameObjects)
{
  currentObject->frameEvent();
  currentObject->frameEndEvent();
  currentObject->DrawEvent();
}

无论使用哪种类型，最后一个（循环范围）都应该有效（您可以使用普通指针或 shared_ptr 或 unique_ptr ，如示例所示）。

如果您有兴趣使用unique_ptr，请注意，要将这些存储在std::vector 上，您必须使用std::move，因为std::unique_ptr 只能有一个实例（顾名思义） . Consult this answer 如有问题。

Answer 2

您必须使用std::vector<Framework*> 或std::vector<std::unique_ptr<Framework>>（或您选择的智能指针）来避免对象切片。

代码示例：

std::vector<std::unique_ptr<Framework>> gameObjects;

gameObjects.push_back(std::make_unique<Player>(/**/));
gameObjects.push_back(std::make_unique<Wall>(/**/));

然后

for (auto& currentObject : gameObjects)
{
    currentObject->frameEvent();
    currentObject->frameEndEvent();
    currentObject->drawEvent();
}

Answer 3

存储指向Framework 的指针并利用多态性。

// Base class
class Framework {
    // Make pure virtual if nothing is done here.
    virtual void frameEvent(); // = 0;

    // To ensure the derived instances are deleted properly.
    virtual ~Framework(); // = default;
};

// Some specialized class
class SomeObject : public Framework {
    void frameEvent() override; // C++11 style override.
};

std::vector<std::unique_ptr<Framework>> objects;

// Add a new SomeObject to the list
objects.emplace_back(new SomeObject());

Answer 4

嗯，直接的答案是 - 你不知道。或者你会得到你已经遇到过的对象切片。您需要使用 C++ 的多态能力并将对象的公共接口存储在向量中。稍后您可以根据实际对象类型调用具有不同实现的接口函数来调用所需的行为。

Answer 5

您必须在Framework 中将frameEvent、frameEndEvent 和drawEvent 设为虚拟。然后，将std::shared_ptr 存储在您的向量中：

std::vector<std::shared_ptr<Framework>> objects;
objects.push_back(new GameObject());

for (vector<Framework>::iterator num = gameObjects.begin(); num != gameObjects.end(); ++num)
{
  //The current thing
  const Framework& currentObject = **num; // reference, don't copy anything if you don't need to
  currentObject.frameEvent();
  currentObject.frameEndEvent();
  currentObject.drawEvent();
}

请注意，您可以将unique_ptr 存储在向量as long as you don't use operations that require copying elements 中。

另一种选择，如果你不能使函数成为虚拟函数并且知道你正在处理什么类型的对象，你可以先强制转换然后调用非虚拟函数：

const PlayerObject& player = static_cast<const PlayerObject&>(*objects[0]);
player.frameEvent();
player.frameEndEvent();
player.drawEvent();

Answer 6

您需要将 指针 存储到您的对象。如果您有C++11，那么理想情况下您将使用std::unique_ptr 存储它们（假设您有一个主向量）。

C++03

std::vector<Framework*> gameObjects;

for(std::vector<Framework*>::iterator num = gameObjects.begin();
    num != gameObjects.end(); ++num)
{
    (*num)->frameEvent();
    (*num)->frameEndEvent();
    (*num)->drawEvent();
}

C++ 11

std::vector<std::unique_ptr<Framework>> gameObjects;

for(auto& num: gameObjects)
{
    num->frameEvent();
    num->frameEndEvent();
    num->drawEvent();
}

Answer 7

将指针存储在向量中，而不是实际的实例中。

Answer 8

另一种可能更快的方法是将它们存储在单独的向量中。由于更高的缓存效率，它可以快 50 倍。