当我不希望它被调用时，C++ 析构函数被调用

Question

我在一些代码中添加了一个析构函数，它似乎提前调用并导致了问题。我添加了一个调试语句来查看它被调用的位置，这让我更加困惑。我知道管理自己的内存不是最佳做法，但我想自己尝试一下。

这基本上是我的 GameObject 类:

class GameObject
{
public:
int             xCoord = 0, yCoord = 0, prevX, prevY;
int             status = 0, weight = -1;
int             id = -1;

GameObject(CommandComponent* commands,
    PhysicsComponent* physics,
    GraphicsComponent* graphics)
    : commandComponent(commands),
    physicsComponent(physics),
    graphicsComponent(graphics)
{};

~GameObject()
{
    std::cout << "Destructor called " << id << std::endl;
    delete commandComponent;
    delete physicsComponent;
    delete graphicsComponent;
};

void update(World& world, int command, sf::Time dt)
{
    commandComponent->update(*this, world, command);
    physicsComponent->update(*this, world);
    graphicsComponent->update(*this, dt);
};

void update(World& world, int command)
{
    commandComponent->update(*this, world, command);
    physicsComponent->update(*this, world);
};

sf::Sprite draw()
{
    return *(graphicsComponent->draw());
};

void setCoords(int x, int y)
{
    prevX = xCoord;
    xCoord = x;
    prevY = yCoord;
    yCoord = y;
};

void setId(int newId)
{
    id = newId;
}


private:
    CommandComponent*           commandComponent    = NULL;
    GraphicsComponent*          graphicsComponent   = NULL;
    PhysicsComponent*           physicsComponent    = NULL;

};

这是 createPlayer 方法:

    GameObject* createPlayer(sf::Texture* text)
{
    return new GameObject(new PlayerCommandComponent(), new PlayerPhysicsComponent(), new PlayerGraphicsComponent(text));
};

这是我调用的一种方法，根据它是事件对象还是非事件对象将新对象添加到 vector 中，我还将它添加到数组中:

void World::addObject(GameObject object, int id, int type){
object.setId(id);

if (type == 0)
{
    inactiveObjects.push_back(object);
}
else if (type == 1)
{
    activeObjects.push_back(object);
}
}

最后，这是我的测试代码，它创建了游戏对象并调用了上面的函数，我在其中看到了调用析构函数的位置:

void World::test()
{
// Player
std::cout << "Starting to create id 0\n";
addObject((*createPlayer(&(mTextures.get(Textures::PlayerCharacter)))), 0, 1);
activeObjects.at(0).setCoords(3, 3);
activeObjects.at(0).weight = 10;
std::cout << "Created id 0\n";

// Test Objects
std::cout << "Starting to create id 1\n";
addObject((*createPlayer(&(mTextures.get(Textures::PlayerCharacter)))), 1, 1);
activeObjects.at(1).setCoords(3, 4);
activeObjects.at(1).weight = 7;
std::cout << "Created id 1\n";

addObject((*createPlayer(&(mTextures.get(Textures::PlayerCharacter)))), 2, 1);
activeObjects.at(2).setCoords(5, 4);
activeObjects.at(2).weight = 2;

addObject((*createPlayer(&(mTextures.get(Textures::Enemy)))), 3, 1);
activeObjects.at(3).setCoords(6, 6);
activeObjects.at(3).weight = -1;

addObject((*createPlayer(&(mTextures.get(Textures::Enemy)))), 4, 1);
activeObjects.at(4).setCoords(1, 1);
activeObjects.at(4).weight = 0;

std::cout << "Done Creating Test Objects\n";

我想我的主要问题是为什么会调用析构函数？我假设它与我在 createPlayer 方法中构建对象的方式有关，也许它在我返回它后超出了范围，但我认为使用 new 关键字可以防止这种情况发生？我在这里很困惑。

Answer 1

这里有几件事在起作用。

GameObject* createPlayer(sf::Texture* text)

返回一个动态分配的GameObject。 This could be done better ，阅读 std::unique_ptr，但这里并没有严格的错误。我提到它主要是为了指出 std::unique_ptr 并设置

addObject((*createPlayer(&(mTextures.get(Textures::PlayerCharacter)))), 0, 1);

因为这是事情开始出错的地方。当您发现使用 new 并取消引用并丢弃结果的代码时，您正在寻找内存泄漏。您已经丢失了指向动态分配对象的指针，如果没有该指针，则几乎不可能再次找到该分配以便您可以删除它。

存储取消引用的对象将调用复制构造函数或赋值运算符，此时您需要考虑 The Rule of Three :如果您需要定义一个自定义析构函数，您可能需要定义一个自定义赋值运算符和一个复制构造函数。这是您何时需要观察 Rule of Three 的标准示例.问题在 Rule of Three 中得到了很好的解释。链接，所以在继续之前停下来，阅读并理解它。不这样做意味着这个答案的其余部分对您几乎毫无用处。

如果不牢牢掌握 the Rule of Three and all of its friends，您就无法编写出色的、不平凡的 C++ 代码.

你可以在这里通过改变绕过三法则

void World::addObject(GameObject object, int id, int type)

到

void World::addObject(GameObject * object, int id, int type)

并通过引用传递object。这没有多大帮助，因为

inactiveObjects.push_back(object);

期待一个对象，而不是一个指针。

您也可以更改它，但是您应该这样做吗？ std::vector 在直接包含一个对象时绝对是最好的。指针导致指针追逐、缓存行为不佳，并最终导致 suuuhhhfering .除非有令人信服的理由，否则不要存储指针。

如果这样做，从头到尾用 std::unique_ptr 管理指针。

我会做什么:

直接跳过三法则并转到 The Rule of Five .

1. 尽可能多地消除动态分配的变量，这样我就不需要为第 2 点做太多工作(如果有的话)。这意味着没有指向(或位于)commandComponent 的指针，physicsComponent 和 graphicsComponent(如果可能)。
2. 向 GameObject 以及 CommandComponent、PhysicsComponent 和 GraphicsComponent 添加移动构造函数和移动赋值运算符.让所有资源管理尽可能靠近资源。这使您可以让更高级别的类尽可能无知。如果 GraphicsComponent 知道如何复制和移动自己，GameObject 就不需要知道如何移动它。这使您可以利用 The Rule of Zero ，而零规则应该是您在所有类(class)中所追求的目标。
3. 使用移动语义从 createPlayer 到 activeObjects 获取 GameObject，而不是 GameObject* 并且inactiveObjects vectors.
4. 享受减少的内存管理负载。