试图删除最后一个std ::向量元素时，程序会崩溃

Question

我正在通过向量std::vector<Bullet*> bullets迭代，我正在寻找与敌人的碰撞。在每种情况下，它都可以很好地工作，除了以下情况：最后一个射击子弹（必须有多个）与敌人相撞。

代码 -

for(std::vector<Bullet*>::iterator it = bullets.begin(); it != bullets.end(); ++it)
{
    if ((*it)->getSprite()->getGlobalBounds().intersects(enemy->getSprite()->getGlobalBounds()))
    {
        delete *it;
        bullets.erase(it);
        enemy->destroy();
        if (bullets.size() == 0)
            break;
    }
}

我评论了for循环中的特定元素，并发现bullet.erase(it)调用崩溃了程序。发生崩溃时，我会收到一个返回代码：134（0x86）。该代码的问题是什么？

(*it)->getSprite()从Bullet类返回指向精灵的指针。

Answer 1

使用remove_if和erase组合：

auto is_hit = [&enemy](Bullet *bullet)
{
    if (bullet->getSprite()->getGlobalBounds().intersects(enemy->getSprite()->getGlobalBounds()))
    {
        delete bullet;
        enemy->destroy();
        return true;
    }
    return false;
};
bullets.erase(std::remove_if(bullets.begin(), bullets.end(), is_hit), bullets.end());

Answer 2

供您考虑：

以下代码段显示了我如何从尾巴上清洁矢量（用push_back（））添加元素的互补动作（））

while(!gBoard.empty())
{
   Cell_t* cell = gBoard.back();  // fetch last element (a ptr)
   gBoard.pop_back();             // remove last element
   delete cell;                   // remove cell from heap - raw pointer
}  

也许您可以做这种干净的风格并使用多个向量...它可能比其他替代品快。

在您的问题中，每个子弹似乎至少有两个目的地...命中或错过。

while ( ! Bullets.empty() )   // spin through bullet list
{
    Bullet* aBullet = Bullets.back();  // fetch copy of last element
    Bullets.pop_back();                // remove last element 
    if (*aBullet)-> getSprite()->getGlobalBounds().    
           intersects(enemy->getSprite()->getGlobalBounds()))
    {  
       // HIT!
       Hit.push_back(aBullet); // capture the element to Hit bucket
       enemy->destroy();       // tbd - a decision? or always final?
       // no delete 
       if (bullets.size() == 0) // no more to compute, redundant to while
           break;
    }
    else
    {
       // MISS 
       Missed.push_back(aBullet);  // capture element to Missed bucket
    }
} // while 
assert(bullets.empty());  // bullets have been consumed
// clean up spent bullets that intersected
while (! Hit.empty() )
{
   Bullet* aBullet = Hit.back(); // copy last element from Hit
   Hit.pop_back();               // remove last element from Hit
   delete aBullet;               // tbr - delete the dynamic memory
}
// clean up spent bullets that missed 
// move the bullet from Missed vec back into Bullets vec
//    for tbd - furthur evaluation ... did the bullet hit any other obj
// the following also happens to 'undo' the seq reversal
while (! Missed.empty() )
{
   Bullets.push_back (Missed.back()); // copy last element from Missed
   Missed.pop_back();                 // remove last element from Missed
   // tbd - also delete the missed bullet?
   //   or do you check for these bullets to collide with other objects
}
// possibly a copy can do this last loop, but this is simple and 
// undoes the reversal.

Answer 3

并发现子弹（it）调用[最后一个元素] 崩溃程序

从某种意义上说，您可能正在过早执行擦除。

考虑以下内容：

范围，目标和武器类型的测试参数可能结合起来，例如10％的命中率。因此，在1000张镜头的集合中（1000 == Bullets.size（）），将有（〜）100个子弹击中目标。

您的代码找到每个元素，并使用Bullets.erase（）在向量中创建100个"孔"。由于矢量数据是连续的，因此擦除方法还移动其他元素以填充擦除所产生的孔。（实施之间可能有所不同的详细信息。）

通常，100次擦除会导致100个休息时间小于（最重要的）每次1000个元素...这个一次性接触可能是一个相对"慢"的过程。

---

作为当前设计的替代方案，而不是查找和校正，将擦除延迟到您的代码已识别并标记所有"相互作用"。

• 您可以以相同的方式找到相交（命中），但是"标记"它们，不要删除它们。选项包括在子弹类中添加布尔，或维护匹配的布尔向量以保存每个子弹的标志。

• 使用两个索引

  - I1初始化为0（首先（左）向量元素）和

  - i2初始化为（bullets.size（） - 1）[最后（右）向量元素]

- 旋转i1以找到第一个命中

- 自旋减少i2以找到最后的错过，

- 然后std ::交换（子弹[I1]，子弹[I2]）

重复直到i1> = i2

现在，所有命中都是连续的，在向量的尾部，执行100点命中的单个擦除

这应该消除任何改组。

另外，不应使用擦除的元素...因为擦除发生在过程结束时。