Удаление элементов из std :: set во время итерации

Это зависит от реализации:

Стандарт 23.1.2.8:

Элементы вставки не должны влиять на действительность итераторов и ссылок на контейнер, а элементы удаления должны аннулировать только итераторы и ссылки на удаленные элементы.

Возможно, вы могли бы попробовать это - это соответствует стандарту:

for (auto it = numbers.begin(); it != numbers.end(); ) {
    if (*it % 2 == 0) {
        numbers.erase(it++);
    }
    else {
        ++it;
    }
}

Обратите внимание, что это ++ - постфиксный, поэтому он передает старую позицию для стирания, но сначала переходит к более новой из-за оператора.

Обновление 2015.10.27: C ++ 11 устранил дефект. iterator erase (const_iterator position); возвращает итератор к элементу, который следует за последним удаленным элементом (или set::end, если последний элемент был удален). Итак, стиль C ++ 11:

for (auto it = numbers.begin(); it != numbers.end(); ) {
    if (*it % 2 == 0) {
        it = numbers.erase(it);
    }
    else {
        ++it;
    }
}

Если вы запустите свою программу через valgrind, вы увидите кучу ошибок чтения. Другими словами, да, итераторы становятся недействительными, но в вашем примере вам повезло (или действительно не повезло, поскольку вы не видите отрицательных эффектов неопределенного поведения). Одним из решений этого является создание временного итератора, увеличение значения temp, удаление целевого итератора, а затем установка целевого значения temp. Например, перепишите свой цикл следующим образом:

std::set<int>::iterator it = numbers.begin();                               
std::set<int>::iterator tmp;                                                

// iterate through the set and erase all even numbers                       
for ( ; it != numbers.end(); )                                              
{                                                                           
    int n = *it;                                                            
    if (n % 2 == 0)                                                         
    {                                                                       
        tmp = it;                                                           
        ++tmp;                                                              
        numbers.erase(it);                                                  
        it = tmp;                                                           
    }                                                                       
    else                                                                    
    {                                                                       
        ++it;                                                               
    }                                                                       
} 

Вы неправильно понимаете, что означает «неопределенное поведение». Неопределенное поведение не означает, что «если вы сделаете это, ваша программа будет аварийно завершена или выдаст неожиданные результаты». Это означает «если вы сделаете это, ваша программа может дать сбой или дать неожиданные результаты» или сделать что-нибудь еще, в зависимости от вашего компилятора, вашей операционной системы, фазы луны и т. Д.

Если что-то выполняется без сбоев и ведет себя так, как вы ожидаете, это не доказывает, что это не неопределенное поведение. Все, что он доказывает, - это то, что его поведение соответствовало наблюдаемому для этого конкретного запуска после компиляции с этим конкретным компилятором в этой конкретной операционной системе.

Удаление элемента из набора делает недействительным итератор для стертого элемента. Использование недействительного итератора - неопределенное поведение. Так уж получилось, что наблюдаемое поведение было тем, что вы планировали в данном конкретном случае; это не значит, что код правильный.

В C ++ 20 будет «равномерное стирание контейнера», и вы сможете написать:

std::erase_if(numbers, [](int n){ return n % 2 == 0 });

И это будет работать для vector, set, deque и т. Д. См. cppReference для получения дополнительной информации.

Просто чтобы предупредить, что в случае контейнера двухсторонней очереди все решения, которые проверяют равенство двухсторонней очереди итератору number.end (), скорее всего, не будут выполнены в gcc 4.8.4. А именно, стирание элемента двухсторонней очереди обычно делает недействительным указатель на numbers.end ():

#include <iostream>
#include <deque>

using namespace std;
int main() 
{

  deque<int> numbers;

  numbers.push_back(0);
  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);
  //numbers.push_back(4);

  deque<int>::iterator  it_end = numbers.end();

  for (deque<int>::iterator it = numbers.begin(); it != numbers.end(); ) {
    if (*it % 2 == 0) {
      cout << "Erasing element: " << *it << "\n";
      numbers.erase(it++);
      if (it_end == numbers.end()) {
    cout << "it_end is still pointing to numbers.end()\n";
      } else {
    cout << "it_end is not anymore pointing to numbers.end()\n";
      }
    }
    else {
      cout << "Skipping element: " << *it << "\n";
      ++it;
    }
  }
}

Выход:

Erasing element: 0
it_end is still pointing to numbers.end()
Skipping element: 1
Erasing element: 2
it_end is not anymore pointing to numbers.end()

Обратите внимание, что, хотя преобразование двухсторонней очереди в данном конкретном случае является правильным, конечный указатель был признан недействительным на этом пути. Для двухсторонней очереди другого размера ошибка более очевидна:

int main() 
{

  deque<int> numbers;

  numbers.push_back(0);
  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);
  numbers.push_back(4);

  deque<int>::iterator  it_end = numbers.end();

  for (deque<int>::iterator it = numbers.begin(); it != numbers.end(); ) {
    if (*it % 2 == 0) {
      cout << "Erasing element: " << *it << "\n";
      numbers.erase(it++);
      if (it_end == numbers.end()) {
    cout << "it_end is still pointing to numbers.end()\n";
      } else {
    cout << "it_end is not anymore pointing to numbers.end()\n";
      }
    }
    else {
      cout << "Skipping element: " << *it << "\n";
      ++it;
    }
  }
}

Выход:

Erasing element: 0
it_end is still pointing to numbers.end()
Skipping element: 1
Erasing element: 2
it_end is still pointing to numbers.end()
Skipping element: 3
Erasing element: 4
it_end is not anymore pointing to numbers.end()
Erasing element: 0
it_end is not anymore pointing to numbers.end()
Erasing element: 0
it_end is not anymore pointing to numbers.end()
...
Segmentation fault (core dumped)

Вот один из способов исправить это:

#include <iostream>
#include <deque>

using namespace std;
int main() 
{

  deque<int> numbers;
  bool done_iterating = false;

  numbers.push_back(0);
  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);
  numbers.push_back(4);

  if (!numbers.empty()) {
    deque<int>::iterator it = numbers.begin();
    while (!done_iterating) {
      if (it + 1 == numbers.end()) {
    done_iterating = true;
      } 
      if (*it % 2 == 0) {
    cout << "Erasing element: " << *it << "\n";
      numbers.erase(it++);
      }
      else {
    cout << "Skipping element: " << *it << "\n";
    ++it;
      }
    }
  }
}

Это поведение зависит от реализации. Чтобы гарантировать правильность итератора, вы должны использовать "it = numbers.erase (it);" оператор, если вам нужно удалить элемент и просто включить итератор в другом случае.

Я думаю, что использование метода STL 'remove_if' from могло бы помочь предотвратить некоторые странные проблемы при попытке удалить объект, обернутый итератором.

Это решение может быть менее эффективным.

Допустим, у нас есть какой-то контейнер, например вектор или список с именем m_bullets:

Bullet::Ptr is a shared_pr<Bullet>

«it» - это итератор, который возвращает «remove_if», третий аргумент - это лямбда-функция, которая выполняется для каждого элемента контейнера. Поскольку контейнер содержит Bullet::Ptr, лямбда-функции необходимо передать этот тип (или ссылку на этот тип) в качестве аргумента.

 auto it = std::remove_if(m_bullets.begin(), m_bullets.end(), [](Bullet::Ptr bullet){
    // dead bullets need to be removed from the container
    if (!bullet->isAlive()) {
        // lambda function returns true, thus this element is 'removed'
        return true;
    }
    else{
        // in the other case, that the bullet is still alive and we can do
        // stuff with it, like rendering and what not.
        bullet->render(); // while checking, we do render work at the same time
        // then we could either do another check or directly say that we don't
        // want the bullet to be removed.
        return false;
    }
});
// The interesting part is, that all of those objects were not really
// completely removed, as the space of the deleted objects does still 
// exist and needs to be removed if you do not want to manually fill it later 
// on with any other objects.
// erase dead bullets
m_bullets.erase(it, m_bullets.end());

«remove_if» удаляет контейнер, в котором лямбда-функция вернула истину, и перемещает это содержимое в начало контейнера. 'it' указывает на неопределенный объект, который можно рассматривать как мусор. Объекты от 'it' до m_bullets.end () могут быть удалены, поскольку они занимают память, но содержат мусор, поэтому для этого диапазона вызывается метод 'erase'.

Я столкнулся с той же старой проблемой и обнаружил, что приведенный ниже код более понятен, что соответствует приведенным выше решениям.

std::set<int*>::iterator beginIt = listOfInts.begin();
while(beginIt != listOfInts.end())
{
    // Use your member
    std::cout<<(*beginIt)<<std::endl;

    // delete the object
    delete (*beginIt);

    // erase item from vector
    listOfInts.erase(beginIt );

    // re-calculate the begin
    beginIt = listOfInts.begin();
}