반복하면서 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 (TCollection이 아닌 list로 작업하는 것을 알고있는 경우)
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와 결합 된 funtion 사용 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를 제거한 후에는 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 );
    }
}

추신 : 예를 들어 역 반복과 관련하여 이것을 참조하십시오 .

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또는 경우에 당신은 일반적인 코드를 작성 항목 (벡터 같은) 하나의 항목을 삭제하는 효과적인 방법으로 컨테이너 수 있습니다 - 관용구는 항목이 O (N)에 compexity을 유지하는 대신 목록의 벡터 일 때 사용되어야한다

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);
}