vetor apagar iterador

Eu tenho esse 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; } } 

“Um iterador de access random apontando para a nova localização do elemento que seguiu o último elemento apagado pela chamada de function, que é o final do vetor se a operação apagou o último elemento na sequência.”

Este código trava, mas se eu usar o if (it == res.end ()) e, em seguida, retorna funciona. Por quê? O loop for desconta o res.end () para que o operador não igual falhe?

    res.erase(it) sempre retorna o próximo iterador válido, se você apagar o último elemento, ele apontará para .end()

    No final do loop ++it é sempre chamado, então você incrementa .end() que não é permitido.

    A simples verificação de .end() ainda deixa um bug, já que você sempre pula um elemento em cada iteração ( it é ‘incrementado’ pelo retorno de .erase() , e novamente pelo loop)

    Você provavelmente quer algo como:

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

    para apagar cada elemento

    (para completar: eu suponho que este é um exemplo simplificado, se você simplesmente quer que todos os elementos acabem sem ter que executar uma operação nele (por exemplo, delete) você deve simplesmente chamar res.clear() )

    Quando você apenas apaga condicionalmente os elementos, provavelmente quer algo como

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

    ou, mais geral:

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

    Como uma modificação na resposta do crazylammer, eu uso frequentemente:

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

    A vantagem disso é que você não precisa se preocupar em esquecer de incrementar seu iterador, tornando-o menos propenso a erros quando tiver lógica complexa. Dentro do loop, curr nunca será igual a res.end (), e será no próximo elemento, independentemente de você apagá-lo do seu vetor.

    Não apague e depois incremente o iterador. Não há necessidade de incrementar, se o seu vetor tiver um número ímpar de elementos (ou até mesmo não sei), você perderá o final do vetor.

    A instrução ++ é feita no final do bloco. Portanto, se você estiver apagando o último elemento, tente incrementar o iterador que está apontando para uma coleção vazia.

    Você o incrementa após o final do contêiner (vazio) na expressão de loop do loop for.

    O seguinte também parece funcionar:

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

    Não tenho certeza se há alguma falha nisso?

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

    Isso funciona para mim. E não precisa pensar em índices já apagados.

    Porque o método apaga no vetor retorna o próximo iterador do iterador passado.

    Vou dar exemplo de como remover elemento no vetor quando 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< 

    saída aw abaixo:

     024 024 024 

    Um método mais gerar:

     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<