Bạn có thể xóa các thành phần khỏi danh sách std :: trong khi lặp qua nó không?

Tôi đã có mã trông như thế này:

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

Tôi muốn xóa các mục không hoạt động ngay sau khi cập nhật chúng, inorder để tránh đi lại danh sách. Nhưng nếu tôi thêm các dòng nhận xét, tôi sẽ gặp lỗi khi nhận được i++: "Danh sách trình lặp không thể tăng". Tôi đã thử một số lựa chọn thay thế không tăng trong tuyên bố, nhưng tôi không thể làm gì được.

Cách tốt nhất để xóa các mục khi bạn đang đi trong danh sách std :: là gì?

Bạn phải tăng iterator trước (với i ++) và sau đó loại bỏ phần tử trước đó (ví dụ: bằng cách sử dụng giá trị được trả về từ i ++). Bạn có thể thay đổi mã thành một vòng lặp while như vậy:

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

Bạn muốn làm:

i= items.erase(i);

Điều đó sẽ cập nhật chính xác trình lặp để trỏ đến vị trí sau khi trình lặp mà bạn đã xóa.

Bạn cần thực hiện kết hợp câu trả lời của Kristo và 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);
    }
}

Tất nhiên, điều khôn ngoan hiệu quả nhất và SuperCool® STL sẽ giống như thế này:

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

Sử dụng thuật toán std :: remove_if.

Chỉnh sửa: Làm việc với các bộ sưu tập nên như sau: 1. chuẩn bị bộ sưu tập. 2. quy trình thu thập.

Cuộc sống sẽ dễ dàng hơn nếu bạn không trộn các bước này.

1. std :: remove_if. hoặc list :: remove_if (nếu bạn biết rằng bạn làm việc với danh sách chứ không phải với TCollection)
2. std :: for_each

Dưới đây là một ví dụ sử dụng forvòng lặp lặp lại danh sách và tăng hoặc xác nhận lại trình lặp trong trường hợp một mục bị xóa trong quá trình duyệt qua danh sách.

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

Thay thế cho phiên bản vòng lặp để trả lời của Kristo.

Bạn mất một số hiệu quả, bạn quay trở lại và sau đó chuyển tiếp một lần nữa khi xóa nhưng để đổi lấy gia tăng vòng lặp bổ sung, bạn có thể có trình lặp được khai báo trong phạm vi vòng lặp và mã trông sạch hơn một chút. Chọn gì phụ thuộc vào ưu tiên của thời điểm này.

Câu trả lời đã hết thời, tôi biết ...

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

Tôi có sumup nó, đây là ba phương pháp với ví dụ:

1. sử dụng whilevòng lặp

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. sử dụng remove_ifchức năng thành viên trong danh sách:

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. sử dụng std::remove_ifchức năng kết hợp với erasechức năng thành viên:

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. sử dụng forvòng lặp, cần lưu ý cập nhật iterator:

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 

Việc xóa chỉ làm mất hiệu lực các trình vòng lặp trỏ đến các phần tử được loại bỏ.

Vì vậy, trong trường hợp này sau khi xóa * i, i bị vô hiệu và bạn không thể thực hiện gia tăng trên đó.

Những gì bạn có thể làm trước tiên là lưu iterator của phần tử cần loại bỏ, sau đó tăng iterator và sau đó loại bỏ phần tử đã lưu.

Nếu bạn nghĩ std::listgiống như một hàng đợi, thì bạn có thể dequeue và enqueue tất cả các mục mà bạn muốn giữ, nhưng chỉ dequeue (và không enqueue) các mục bạn muốn loại bỏ. Đây là một ví dụ mà tôi muốn xóa 5 khỏi danh sách chứa các số 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 bây giờ sẽ chỉ có các số 1-4 và 6-10.

Lặp lại ngược lại để tránh hiệu ứng xóa một phần tử trên các phần tử còn lại sẽ được duyệt qua:

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: xem cái này , ví dụ, liên quan đến việc lặp lại.

PS2: Tôi đã không kiểm tra kỹ lưỡng nếu nó xử lý tốt các phần tử xóa ở phần cuối.

Bạn có thể viết

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

Bạn có thể viết mã tương đương với std::list::remove_if, ít dài dòng hơn và rõ ràng hơn

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

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

Thành std::vector::erase std::remove_ifngữ nên được sử dụng khi các mục là một vectơ thay vì danh sách để giữ sự đồng nhất ở O (n) - hoặc trong trường hợp bạn viết mã chung và các mục có thể là một thùng chứa không có cách nào hiệu quả để xóa các mục đơn lẻ (như vectơ)

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

Tôi nghĩ rằng bạn có một lỗi ở đó, tôi mã theo cách này:

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