O que acontece se você chamar erase () em um elemento do mapa enquanto itera do começo ao fim?

133

No código a seguir, percorro um mapa e testo se um elemento precisa ser apagado. É seguro apagar o elemento e manter a iteração ou preciso coletar as chaves em outro contêiner e fazer um segundo loop para chamar erase ()?

map<string, SerialdMsg::SerialFunction_t>::iterator pm_it;
for (pm_it = port_map.begin(); pm_it != port_map.end(); pm_it++)
{
    if (pm_it->second == delete_this_id) {
        port_map.erase(pm_it->first);
    }
}

ATUALIZAÇÃO: Obviamente, eu li essa pergunta que não achei que fosse relacionada, mas responde minha pergunta.

c++ stl iterator

— Matthew Smith
fonte

Observe na pergunta que std::remove_ifnão funciona comstd:map

— socketpair

Respostas:

183

C ++ 11

Isso foi corrigido no C ++ 11 (ou a eliminação foi aprimorada / tornada consistente em todos os tipos de contêiner).
O método apagar agora retorna o próximo iterador.

auto pm_it = port_map.begin();
while(pm_it != port_map.end())
{
    if (pm_it->second == delete_this_id)
    {
        pm_it = port_map.erase(pm_it);
    }
    else
    {
        ++pm_it;
    }
}

C ++ 03

A exclusão de elementos em um mapa não invalida nenhum iterador.
(além dos iteradores no elemento que foi excluído)

Na verdade, inserir ou excluir não invalida nenhum dos iteradores:

Veja também esta resposta:
Mark Ransom Technique

Mas você precisa atualizar seu código:
no seu código, você incrementa pm_it depois de chamar apagar. Neste ponto, é tarde demais e já está invalidado.

map<string, SerialdMsg::SerialFunction_t>::iterator pm_it = port_map.begin();
while(pm_it != port_map.end())
{
    if (pm_it->second == delete_this_id)
    {
        port_map.erase(pm_it++);  // Use iterator.
                                  // Note the post increment.
                                  // Increments the iterator but returns the
                                  // original value for use by erase 
    }
    else
    {
        ++pm_it;           // Can use pre-increment in this case
                           // To make sure you have the efficient version
    }
}

— Martin York
fonte

A ordem de avaliação do incremento na expressão postfix é pm_it++garantida para ser executada antes da entrada da função?

— David Rodríguez - dribeas 03/03

@David Rodríguez - dribeas: Sim. O padrão garante que todas as expressões de argumento serão totalmente avaliadas antes que a função seja chamada. É o resultado do incremento posterior que é passado para a função apagar (). Portanto, sim, o pós-incremento de pm_it será feito antes que apague () seja chamado.

— Martin York

NOTA: Quase linha por linha corresponde ao exemplo recipiente associativo em Scott Meyer de "Effective STL" Item 9.

— Ogre Psalm33

for (auto pm_t = port_map.begin (); pm_it! = port_map.end ();) {...}

— Andrey Syrokomskiy

@iboisver: No vetor. O uso de erase () invalida todos os iteradores da matriz após o ponto de apagamento (não apenas o final), essa é uma propriedade dos Sequencecontêineres. A propriedade especial dos Associativecontêineres é que os iteradores não são invalidados por apagar ou inserir (a menos que aponte para o elemento que foi apagado). Vector e apaga iteradores de design de usuário são abordados detalhadamente na pergunta apropriada stackoverflow.com/a/3938847/14065

— Martin York

Aqui está como eu faço isso ...

typedef map<string, string>   StringsMap;
typedef StringsMap::iterator  StrinsMapIterator;

StringsMap m_TheMap; // Your map, fill it up with data    

bool IsTheOneToDelete(string str)
{
     return true; // Add your deletion criteria logic here
}

void SelectiveDelete()
{
     StringsMapIter itBegin = m_TheMap.begin();
     StringsMapIter itEnd   = m_TheMap.end();
     StringsMapIter itTemp;

     while (itBegin != itEnd)
     {
          if (IsTheOneToDelete(itBegin->second)) // Criteria checking here
          {
               itTemp = itBegin;          // Keep a reference to the iter
               ++itBegin;                 // Advance in the map
               m_TheMap.erase(itTemp);    // Erase it !!!
          }
          else
               ++itBegin;                 // Just move on ...
     }
}

— AlaaShaker
fonte

Se você excluir o final do vetor também (itEnd), a última verificação (a condição while) será contra um iterador inválido (itEnd). Não é bom.

— Agostino

É assim que eu faria, aproximadamente:

bool is_remove( pair<string, SerialdMsg::SerialFunction_t> val )
{
    return val.second == delete_this_id;
}

map<string, SerialdMsg::SerialFunction_t>::iterator new_end = 
    remove_if (port_map.begin( ), port_map.end( ), is_remove );

port_map.erase (new_end, port_map.end( ) );

Há algo estranho sobre

val.second == delete_this_id

mas apenas copiei do seu código de exemplo.

— Ravenspoint
fonte