คุณสามารถลบองค์ประกอบออกจากรายการ std :: ในขณะที่วนซ้ำมันได้หรือไม่?

ฉันมีรหัสที่มีลักษณะดังนี้:

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++: "List iterator ไม่สามารถเพิ่มได้" ฉันลองใช้ตัวเลือกอื่นซึ่งไม่ได้เพิ่มในคำสั่ง for แต่ฉันไม่สามารถทำงานอะไรได้

เป็นวิธีที่ดีที่สุดในการลบรายการในขณะที่คุณกำลังเดินรายการ std :: อะไร

คุณต้องเพิ่มตัววนซ้ำก่อน (ด้วย i ++) จากนั้นลบองค์ประกอบก่อนหน้า (เช่นโดยใช้ค่าที่ส่งคืนจาก i ++) คุณสามารถเปลี่ยนรหัสเป็นวงขณะที่ดังนี้:

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 savy จะเป็นดังนี้:

// 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. มาตรฐาน :: remove_if หรือ list :: remove_if (ถ้าคุณรู้ว่าคุณทำงานกับ list และไม่ใช่กับ TCollection)
2. มาตรฐาน :: 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สมาชิก funtion ในรายการ:

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_iffuntion รวมกับ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. การใช้forลูปควรทราบการอัพเดตตัววนซ้ำ:

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เหมือนคิวคุณสามารถถอนและจัดคิวรายการทั้งหมดที่คุณต้องการเก็บไว้ แต่ถอนเฉพาะรายการ (และไม่เข้าคิว) รายการที่คุณต้องการลบ นี่คือตัวอย่างที่ฉันต้องการลบ 5 จากรายการที่มีตัวเลข 1-10 ...

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