矢量擦除迭代器

我有这个代码：

int main()
{
    vector<int> res;
    res.push_back(1);
    vector<int>::iterator it = res.begin();
    for( ; it != res.end(); it++)
    {
        it = res.erase(it);
        //if(it == res.end())
        //  return 0;
    }
}

“一个随机访问迭代器，指向在函数调用删除的最后一个元素之后的元素的新位置，如果操作删除了序列中的最后一个元素，则该向量为向量结束。”

此代码崩溃，但是如果我使用该if(it == res.end())部分然后返回，则可以正常工作。怎么来的？for循环是否缓存，res.end()以便不等于运算符失败？

res.erase(it) 始终返回下一个有效的迭代器，如果您删除最后一个元素，它将指向 .end()

在循环的末尾++it总是被调用，因此您.end()不允许递增。

简单地检查.end()仍然会留下一个错误，因为您总是在每次迭代中跳过一个元素（it从的返回值“递增” .erase()，然后在循环中再次递增）

您可能想要类似的东西：

 while (it != res.end()) {
        it = res.erase(it);    
 }

擦除每个元素

（为完整起见：我假设这是一个简化的示例，如果您只是希望每个元素都消失而不必对其执行任何操作（例如，删除），则只需调用res.clear()）

当您仅有条件地擦除元素时，您可能想要类似

for ( ; it != res.end(); ) {
  if (condition) {
    it = res.erase(it);
  } else {
    ++it;
  }
}

for( ; it != res.end();)
{
    it = res.erase(it);
}

或更笼统地说：

for( ; it != res.end();)
{
    if (smth)
        it = res.erase(it);
    else
        ++it;
}

因为向量中的方法擦除会返回传递的迭代器的下一个迭代器。

我将举例说明如何在迭代时删除向量中的元素。

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};

    //method 1
    for(auto it = vecInt.begin();it != vecInt.end();){
        if(*it % 2){// remove all the odds
            it = vecInt.erase(it); // note it will = next(it) after erase
        } else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 2
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 2
    for(auto it=std::begin(vecInt);it!=std::end(vecInt);){
        if (*it % 2){
            it = vecInt.erase(it);
        }else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 3
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 3
    vecInt.erase(std::remove_if(vecInt.begin(), vecInt.end(),
                 [](const int a){return a % 2;}),
                 vecInt.end());

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

}

在下面输出aw：

024
024
024

更多生成方法：

template<class Container, class F>
void erase_where(Container& c, F&& f)
{
    c.erase(std::remove_if(c.begin(), c.end(),std::forward<F>(f)),
            c.end());
}

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};
    //method 4
    auto is_odd = [](int x){return x % 2;};
    erase_where(vecInt, is_odd);

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;    
}

it ++指令在该块的末尾完成。因此，如果要擦除最后一个元素，则尝试增加指向空集合的迭代器。

您可以使用现代C ++进行的操作是使用“ std :: remove_if”和lambda表达式；

此代码将删除向量的“ 3”

vector<int> vec {1,2,3,4,5,6};

vec.erase(std::remove_if(begin(vec),end(vec),[](int elem){return (elem == 3);}), end(vec));

不要擦除然后增加迭代器。如果您的向量具有奇数个（或什至我不知道）元素，则无需增加，您将错过向量的结尾。

您会增加itfor循环的循环表达式中（空）容器的末尾。

以下似乎也起作用：

for (vector<int>::iterator it = res.begin(); it != res.end(); it++)
{
  res.erase(it--);
}

不知道这是否有任何缺陷？

if(allPlayers.empty() == false) {
    for(int i = allPlayers.size() - 1; i >= 0; i--)
    {
        if(allPlayers.at(i).getpMoney() <= 0) 
            allPlayers.erase(allPlayers.at(i));
    }
}

这对我有用。而且，无需考虑索引已被删除。

作为对crazylammer答案的修改，我经常使用：

your_vector_type::iterator it;
for( it = res.start(); it != res.end();)
{
    your_vector_type::iterator curr = it++;
    if (something)
        res.erase(curr);
}

这样做的好处是，您不必担心忘记增加迭代器，从而在具有复杂逻辑时不易出错。在循环内部，curr永远不会等于res.end（），并且无论是否从向量中删除它，它都将位于下一个元素。