您可以在遍历std :: list的同时删除其中的元素吗？

我有看起来像这样的代码：

for (std::list<item*>::iterator i=items.begin();i!=items.end();i++)
{
    bool isActive = (*i)->update();
    //if (!isActive) 
    //  items.remove(*i); 
    //else
       other_code_involving(*i);
}
items.remove_if(CheckItemNotActive);

我想在更新不活动的项目后立即将其删除，以避免再次浏览列表。但是，如果添加注释行，则出现以下错误i++：“列表迭代器不可递增”。我尝试了一些替代方法，这些替代方法在for语句中没有增加，但是我什么也无法工作。

走std :: list时删除项目的最佳方法是什么？

您必须先增加迭代器（使用i ++），然后删除上一个元素（例如，使用i ++的返回值）。您可以将代码更改为while循环，如下所示：

std::list<item*>::iterator i = items.begin();
while (i != items.end())
{
    bool isActive = (*i)->update();
    if (!isActive)
    {
        items.erase(i++);  // alternatively, i = items.erase(i);
    }
    else
    {
        other_code_involving(*i);
        ++i;
    }
}

您想做：

i= items.erase(i);

这将正确更新迭代器，使其指向删除迭代器后的位置。

您需要结合使用Kristo的答案和MSN的答案：

// Note: Using the pre-increment operator is preferred for iterators because
//       there can be a performance gain.
//
// Note: As long as you are iterating from beginning to end, without inserting
//       along the way you can safely save end once; otherwise get it at the
//       top of each loop.

std::list< item * >::iterator iter = items.begin();
std::list< item * >::iterator end  = items.end();

while (iter != end)
{
    item * pItem = *iter;

    if (pItem->update() == true)
    {
        other_code_involving(pItem);
        ++iter;
    }
    else
    {
        // BTW, who is deleting pItem, a.k.a. (*iter)?
        iter = items.erase(iter);
    }
}

当然，最高效，最SuperCool®STL的东西就是这样：

// This implementation of update executes other_code_involving(Item *) if
// this instance needs updating.
//
// This method returns true if this still needs future updates.
//
bool Item::update(void)
{
    if (m_needsUpdates == true)
    {
        m_needsUpdates = other_code_involving(this);
    }

    return (m_needsUpdates);
}

// This call does everything the previous loop did!!! (Including the fact
// that it isn't deleting the items that are erased!)
items.remove_if(std::not1(std::mem_fun(&Item::update)));

使用std :: remove_if算法。

编辑： 使用收藏应该像：1.准备收藏。2.过程收集。

如果您不混淆这些步骤，生活将会更加轻松。

1. std :: remove_if。或list :: remove_if（如果您知道您使用list而不是TCollection）
2. std :: for_each

这是一个使用for循环的示例，该循环在列表遍历期间被删除的情况下迭代列表并递增或重新验证迭代器。

for(auto i = items.begin(); i != items.end();)
{
    if(bool isActive = (*i)->update())
    {
        other_code_involving(*i);
        ++i;

    }
    else
    {
        i = items.erase(i);

    }

}

items.remove_if(CheckItemNotActive);

Kristo的答案的循环版本的替代方法。

您会失去一些效率，在删除时会先后退，然后再前进，但要换取额外的迭代器增量，可以在循环范围中声明迭代器，并使代码看起来更简洁。选择什么取决于当前的优先级。

我知道答案完全没有时间了。

typedef std::list<item*>::iterator item_iterator;

for(item_iterator i = items.begin(); i != items.end(); ++i)
{
    bool isActive = (*i)->update();

    if (!isActive)
    {
        items.erase(i--); 
    }
    else
    {
        other_code_involving(*i);
    }
}

我有总结，这是带有示例的三种方法：

1.使用while循环

list<int> lst{4, 1, 2, 3, 5};

auto it = lst.begin();
while (it != lst.end()){
    if((*it % 2) == 1){
        it = lst.erase(it);// erase and go to next
    } else{
        ++it;  // go to next
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

2. remove_if在列表中使用成员功能：

list<int> lst{4, 1, 2, 3, 5};

lst.remove_if([](int a){return a % 2 == 1;});

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

3，std::remove_if结合erase成员函数使用功能：

list<int> lst{4, 1, 2, 3, 5};

lst.erase(std::remove_if(lst.begin(), lst.end(), [](int a){
    return a % 2 == 1;
}), lst.end());

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

4.使用forloop，应注意更新迭代器：

list<int> lst{4, 1, 2, 3, 5};

for(auto it = lst.begin(); it != lst.end();++it){
    if ((*it % 2) == 1){
        it = lst.erase(it);  erase and go to next(erase will return the next iterator)
        --it;  // as it will be add again in for, so we go back one step
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2 

删除仅使指向被删除元素的迭代器无效。

因此，在这种情况下，删除* i后，我将无效，并且您无法对其进行递增。

您可以做的是先保存要删除的元素的迭代器，然后递增迭代器，然后删除保存的元素。

如果您std::list将队列视为队列，则可以使要保留的所有项目出队并入队，而仅使要删除的项目出队（而不是出队）。这是一个示例，我想从包含数字1-10的列表中删除5 ...

std::list<int> myList;

int size = myList.size(); // The size needs to be saved to iterate through the whole thing

for (int i = 0; i < size; ++i)
{
    int val = myList.back()
    myList.pop_back() // dequeue
    if (val != 5)
    {
         myList.push_front(val) // enqueue if not 5
    }
}

myList 现在只有数字1-4和6-10。

向后迭代可避免在要遍历的其余元素上擦除元素的影响：

typedef list<item*> list_t;
for ( list_t::iterator it = items.end() ; it != items.begin() ; ) {
    --it;
    bool remove = <determine whether to remove>
    if ( remove ) {
        items.erase( it );
    }
}

PS：看到这个，例如，对于落后的迭代。

PS2：我没有彻底测试它是否在末端处理良好的擦除元素。

你可以写

std::list<item*>::iterator i = items.begin();
while (i != items.end())
{
    bool isActive = (*i)->update();
    if (!isActive) {
        i = items.erase(i); 
    } else {
        other_code_involving(*i);
        i++;
    }
}

您可以使用编写等效的代码std::list::remove_if，该代码不那么冗长，也更明确

items.remove_if([] (item*i) {
    bool isActive = (*i)->update();
    if (!isActive) 
        return true;

    other_code_involving(*i);
    return false;
});

该std::vector::erase std::remove_if当项目是保持compexity在O（n）的一个载体，而不是一个列表成语应该使用-或者如果你写通用代码和物品可能与擦除单品（如矢量）没有有效的方法的容器

items.erase(std::remove_if(begin(items), end(items), [] (item*i) {
    bool isActive = (*i)->update();
    if (!isActive) 
        return true;

    other_code_involving(*i);
    return false;
}));

我认为您那里有一个错误，我这样编写：

for (std::list<CAudioChannel *>::iterator itAudioChannel = audioChannels.begin();
             itAudioChannel != audioChannels.end(); )
{
    CAudioChannel *audioChannel = *itAudioChannel;
    std::list<CAudioChannel *>::iterator itCurrentAudioChannel = itAudioChannel;
    itAudioChannel++;

    if (audioChannel->destroyMe)
    {
        audioChannels.erase(itCurrentAudioChannel);
        delete audioChannel;
        continue;
    }
    audioChannel->Mix(outBuffer, numSamples);
}