Posso continuar a usar um iterador depois que um item foi excluído do std :: multimap <>? [duplicado]

Question

Esta questão já tem uma resposta aqui:

• O que acontece se você chamar apagar () em um elemento do mapa, enquanto a iteração a partir do início ao fim? 3 respostas

Posso continuar a usar um multimap iterador mesmo depois de uma chamada para Multimap :: erase ()? Por exemplo:

Blah::iterator iter;
for ( iter = mm.begin();
      iter != mm.end();
      iter ++ )
{
    if ( iter->second == something )
    {
        mm.erase( iter );
    }
}

Caso isso ser esperado para funcionar correctamente, ou é o iterador invalidado após a chamada para apagar? sites de referência como http://www.cplusplus.com/reference/stl/multimap /erase.html está estranhamente quieto sobre este tema dos tempos de vida de iteradores, ou os efeitos de métodos construtivos / destrutivos sobre iteradores.

Answer 1

http://www.sgi.com/tech/stl/Multimap.html

Multimap has the important property that inserting a new element
into a multimap does not invalidate iterators that point to existing
elements. Erasing an element from a multimap also does not invalidate
any iterators, except, of course, for iterators that actually point to
the element that is being erased.

Por isso, deve olhar como este:

Blah::iterator iter;
for ( iter = mm.begin();iter != mm.end();)
{
    if ( iter->second == something )
    {
        mm.erase( iter++ );
        // Use post increment. This increments the iterator but
        // returns a copy of the original iterator to be used by
        // the erase method
    }
    else
    {
        ++iter;   // Use Pre Increment for efficiency.
    }
}

Veja também: o que acontece se você chama apagar () em um elemento do mapa, enquanto a iteração a partir do início ao fim?

e

excluir uma entrada específica no mapa, mas o iterador deve apontar para o elemento seguinte após a eliminação

Answer 2

C ++ padrão 23.1.2.8:

Os membros inserção não afecta a validade dos iteradores e as referências ao recipiente, e os membros apagar deve invalidar apenas iteradores e referências aos elementos apagados.

Este é um requisito comum para todos os contentores associativos, e std :: multimap é um deles.