vector iterador de borrado

Tengo este código:

int main() { vector res; res.push_back(1); vector::iterator it = res.begin(); for( ; it != res.end(); it++) { it = res.erase(it); //if(it == res.end()) // return 0; } } 

“Un iterador de acceso aleatorio que apunta a la nueva ubicación del elemento que siguió al último elemento borrado por la llamada a la función, que es el vector final si la operación borró el último elemento de la secuencia”.

Este código falla pero si uso if (it == res.end ()) y luego lo devuelve funciona. ¿Cómo? ¿El bucle for efectivo el res.end () por lo que el operador no igual falla?

res.erase(it) siempre devuelve el siguiente iterador válido, si borra el último elemento apuntará a .end()

Al final del ciclo ++it siempre se .end() , por lo que incrementa .end() que no está permitido.

Simplemente verificar para .end() aún deja un error, ya que siempre se salta un elemento en cada iteración ( it “incrementa” por el retorno de .erase() , y luego otra vez por el bucle)

Probablemente quieras algo como:

  while (it != res.end()) { it = res.erase(it); } 

borrar cada elemento

(para completar: supongo que este es un ejemplo simplificado, si simplemente quiere que cada elemento se haya ido sin tener que realizar una operación en él (por ejemplo, eliminar), simplemente debe llamar a res.clear() )

Cuando solo se borran elementos condicionalmente, es probable que desee algo como

 for ( ; it != res.end(); ) { if (condition) { it = res.erase(it); } else { ++it; } } 
 for( ; it != res.end();) { it = res.erase(it); } 

o, más general:

 for( ; it != res.end();) { if (smth) it = res.erase(it); else ++it; } 

Como una modificación a la respuesta de crazylammer, a menudo uso:

 your_vector_type::iterator it; for( it = res.start(); it != res.end();) { your_vector_type::iterator curr = it++; if (something) res.erase(curr); } 

La ventaja de esto es que no tiene que preocuparse por olvidarse de incrementar su iterador, lo que lo hace menos propenso a errores cuando tiene una lógica compleja. Dentro del ciclo, curr nunca será igual a res.end (), y estará en el próximo elemento independientemente de si lo borras de tu vector.

No borre y luego incremente el iterador. No es necesario incrementar, si su vector tiene un número de elementos extraño (o incluso no sé), perderá el final del vector.

La instrucción it ++ se realiza al final del bloque. Entonces, si está borrando el último elemento, intente incrementar el iterador que apunta a una colección vacía.

Lo incrementa it allá del final del contenedor (vacío) en la expresión de bucle for.

Lo siguiente también parece funcionar:

 for (vector::iterator it = res.begin(); it != res.end(); it++) { res.erase(it--); } 

¿No estoy seguro de si hay alguna falla en esto?

 if(allPlayers.empty() == false) { for(int i = allPlayers.size() - 1; i >= 0; i--) { if(allPlayers.at(i).getpMoney() < = 0) allPlayers.erase(allPlayers.at(i)); } } 

Esto funciona para mí Y no necesita pensar que los índices ya se han borrado.

Como el método se borra en el vector, devuelve el siguiente iterador del iterador pasado.

Daré un ejemplo de cómo eliminar un elemento en el vector al iterar.

 void test_del_vector(){ std::vector vecInt{0, 1, 2, 3, 4, 5}; //method 1 for(auto it = vecInt.begin();it != vecInt.end();){ if(*it % 2){// remove all the odds it = vecInt.erase(it); // note it will = next(it) after erase } else{ ++it; } } // output all the remaining elements for(auto const& it:vecInt)std::cout<  

salida aw a continuación:

 024 024 024 

Un método más generar:

 template void erase_where(Container& c, F&& f) { c.erase(std::remove_if(c.begin(), c.end(),std::forward(f)), c.end()); } void test_del_vector(){ std::vector vecInt{0, 1, 2, 3, 4, 5}; //method 4 auto is_odd = [](int x){return x % 2;}; erase_where(vecInt, is_odd); // output all the remaining elements for(auto const& it:vecInt)std::cout<