Question

我有一个像这样的指针向量：vector<Operators*> valid_start = {&negative, &values, &numbers, &bracket_left, &functions}; 使用以下代码取消分配内存时，程序崩溃

void deallocate_vector(vector<Operators*> & a)
{
    for(int it = 0; it < a.size(); it++)
    {
        delete a[it];
    }
    a.clear();
}

我看过这些帖子

Does vector::erase() on a vector of object pointers destroy the object itself?

clearing a vector of pointers

Cleaning up an STL list/vector of pointers

Deallocating objects stored in a vector?

并且无法理解为什么此代码失败。我也试过这种形式的释放，这也崩溃了：

for (std::vector<Operators*>::iterator it = a.begin(); it != a.end(); ++it)
{
     delete(*it);
} 
a.clear();

我已经有效地逐字复制了代码，但它仍然失败了。为什么呢？

编辑：

否定声明。其余的指针属于同一类型

struct Operators
{
    std::vector<std::string> members;
    std::vector<Operators*> precedents;
    std::vector<Operators*> followers;
}negative;

negative.members = {"-"};
negative.precedents = {&basic_operators, &values, &numbers, &comma, &bracket_left, &bracket_right, &factorial};
negative.followers = {&bracket_left, &numbers, &values, &functions};

Answer 1

这就是为什么你应该厌倦使用＆amp;在非常可控的情况下。

我不确定public void closeAll() { boolean shouldcloseTop = !topDeltaProperty().isBound(); // unidirection. boolean shouldcloseLeft = !leftDeltaProperty().isBound(); boolean shouldcloseBottom = !bottomDeltaProperty().isBound(); boolean shouldcloseRight = !rightDeltaProperty().isBound(); if(shouldCloseTop) { setTopDelta(getTopDelta() - 0.01); shouldCloseLeft &= getTopDelta() != getLeftDelta(); shouldCloseBottom &= getTopDelta() != getBottomDelta(); shouldCloseRight &= getTopDelta() != getRightDelta(); } if(shouldCloseLeft) { setLeftDelta(getLeftDelta() - 0.01); shouldCloseBottom &= getLeftDelta() != getBottomDelta(); shouldCloseRight &= getLeftDelta() != getRightDelta(); } if(shouldCloseBottom) { setBottomDelta(getBottomDelta() - 0.01); shouldCloseRight &= getBottomDelta() != getRightDelta(); } if(shouldCloseTop) closeTop(); if(shouldCloseLeft) closeLeft(); if(shouldCloseBottom) closeBottom(); if(shouldCloseRight) closeRight(); }是什么，大概是某个类，所以我将给出一个类似的例子，其中包含一个普遍理解并解释它的类型。考虑：

Operator

{ // Some sort of local scope int x = 10; int* xp = &x; }的生命周期由编译器控制。当它进入本地范围时，它在程序的执行框架内“存在于堆栈中”。它是在打开范围/声明范围时创建的，并在范围退出时删除。请注意，编译器实现细节可能意味着它实际上是在不同时间创建/删除的（如果从未使用过，甚至永远不会），但是你可以假设大部分都是这种行为。

现在，x是指向x的指针。如果我删除xp然后编译器删除xp后面的内存，您认为会发生什么？相同的内存被删除两次 - 这是未定义的行为，往往会导致崩溃或更糟。

为了解问题，您可能将此视为：

注意这实际上并不是编译器会做的事情;然而，这有点说明了它实际做的外在行为。

尝试释放对象指针向量时崩溃

1 个答案: