用我的四叉树类溢出堆栈内存，不知道为什么

Question

我一直在研究四叉树类以检测可能的碰撞，但我添加的项目越多，堆栈溢出的速度就越快。

我还注意到，随着程序运行，内存使用量呈线性增加，所以我认为我没有正确删除某些内容，它只是相互堆叠？

我知道大多数堆栈溢出错误是由递归引起的，但它不应该只发生在 100 个对象上。

#include "Quadtree.h"

Quadtree::Quadtree(Rectangle* bounds)
{
    this->bIsSplit = false;
    this->bounds = bounds;
    this->maxObjects = 5;
}

void Quadtree::Split(std::vector<std::pair<SpaceObject*, SpaceObject*>> &collidingObjects)
{
    float x = bounds->x;
    float y = bounds->y;
    float subWidth = bounds->width / 2;
    float subHeight = bounds->height / 2;

    // Top Left
    nodes.push_back(new Quadtree(new Rectangle(x, y, subWidth, subHeight)));
    // Top Right
    nodes.push_back(new Quadtree(new Rectangle(x + subWidth, y, subWidth, subHeight)));
    // Bottom Left
    nodes.push_back(new Quadtree(new Rectangle(x, y + subHeight, subWidth, subHeight)));
    // Bottom Right
    nodes.push_back(new Quadtree(new Rectangle(x + subWidth, y + subHeight, subWidth, subHeight)));

    // takes all the objects in the parent node and splits them into there corresponding subdivided quadtree
    for (auto o : this->objects)
    {
        for (int i = 0; i < nodes.size(); i++)
        {
            if (nodes[i]->bounds->Contains(o->x, o->y, o->size))
            {
                nodes[i]->Insert(o, collidingObjects);
            }
        }
    }

    this->objects.clear();
    this->bIsSplit = true;
}

void Quadtree::Insert(SpaceObject* spaceObject, std::vector<std::pair<SpaceObject*, SpaceObject*>> &collidingObjects)
{
// if the object does not fit inside this quadtree, this isn't the right quadtree
if (!bounds->Contains(spaceObject->x, spaceObject->y, spaceObject->size))
{
    return;
}

if (!bIsSplit && this->objects.size() < maxObjects) // add the object to the quadtree if the max has not been hit
{
    objects.push_back(spaceObject);

    for (auto o : this->objects)
    {
        // if the objects are not the same and overlapping (pythag)
        if (spaceObject != o &&
            ((spaceObject->x - o->x) * (spaceObject->x - o->x)) + ((spaceObject->y - o->y) * (spaceObject->y - o->y)) <= (spaceObject->size + o->size) * (spaceObject->size + o->size))
        {
            // Add colliding pair to the collidingObjects vector
            collidingObjects.push_back(std::make_pair(spaceObject, o));
        }
    }

}
else
{
    if (!this->bIsSplit) // splits the quadtree if this quadtree has not been split yet
    {
        this->Split(collidingObjects);
    }

    // adds the passed in object to one of the subnodes
    for (auto n : nodes)
    {
        n->Insert(spaceObject, collidingObjects);
    }
}
}

void Quadtree::Delete(SpaceObject* spaceObject)
{
    if (!bounds->Contains(spaceObject->x, spaceObject->y, spaceObject->size))
    {
        return;
    }

    if (!bIsSplit)
    {
        for (int i = 0; i < objects.size(); i++)
        {
            if (objects[i] == spaceObject)
            {
                this->objects.erase(objects.begin() + i);
                return;
            }
        }
    }
    else
    {
        for (auto n : nodes)
        {
            n->Delete(spaceObject);
       }
    }
}

void Quadtree::Clear()
{
    if (bIsSplit)
    {
        for (auto n : nodes)
        {
            n->Clear();
        }
        this->bIsSplit = false;
    }
    nodes.clear();
    objects.clear();
}

Answer 1

好吧，我不知道nodes 是什么或Quadtree 是如何定义的，因为您没有显示完整的代码。但是您使用new 是可疑的。 nodes 是指针的集合吗？如果是这样，您可能会将它们丢在地板上，因为它们永远不会被删除。

---

不要到处写this->。成员在成员函数的范围内。您的Quadtree 构造函数应该为常量成员使用内联初始化程序，并为bounds 使用初始化程序列表。而且，在这里使用裸指针是一个危险信号。这个bounds 的所有权是什么？为什么它需要是指针而不是简单的 Rectangle 类型的值？

我想知道你是否习惯了另一种语言，一种使用new 进行所有构造的语言，并且具有引用语义并且对象实际上是指针。 C++ 不同。

我建议在不使用任何指针的情况下编写它。当然，Rectangle 应该是一个值。如果元素可以有效地移动，Quadtree 的向量可以在插入和删除等时有效。所以，Quadtree 应该有一个移动构造函数。如果您还不完全了解构造函数和特殊成员，这可能是一个高级概念。

即使是（尤其是）初学者，您也绝对应该遵循 ⧺C.149 — 不是赤裸裸的 new 或 delete。因此，如果您需要创建一个指向Quadtree 的指针 向量，请将其设为shared_ptr 的向量。请记住，您在 C++ 中没有垃圾收集，因此任何使用指针的东西都必须明确处理生命周期管理的责任。 shared_ptr 的行为会更像你习惯的那样，并且它们可以安全地用于像 vector 这样的容器中。