remove_if equivalente para std :: map

Estaba tratando de borrar una variedad de elementos del mapa en función de una condición particular. ¿Cómo lo hago usando algoritmos STL?

Inicialmente pensé en usar, remove_ifpero no es posible ya que remove_if no funciona para el contenedor asociativo.

¿Existe algún algoritmo equivalente "remove_if" que funcione para el mapa?

Como una opción simple, pensé en recorrer el mapa y borrar. Pero, ¿recorrer el mapa y borrar es una opción segura? (Ya que los iteradores se vuelven inválidos después del borrado)

Usé el siguiente ejemplo:

bool predicate(const std::pair<int,std::string>& x)
{
    return x.first > 2;
}

int main(void) 
{

    std::map<int, std::string> aMap;

    aMap[2] = "two";
    aMap[3] = "three";
    aMap[4] = "four";
    aMap[5] = "five";
    aMap[6] = "six";

//      does not work, an error
//  std::remove_if(aMap.begin(), aMap.end(), predicate);

    std::map<int, std::string>::iterator iter = aMap.begin();
    std::map<int, std::string>::iterator endIter = aMap.end();

    for(; iter != endIter; ++iter)
    {
            if(Some Condition)
            {
                            // is it safe ?
                aMap.erase(iter++);
            }
    }

    return 0;
}

Casi.

for(; iter != endIter; ) {
     if (Some Condition) {
          iter = aMap.erase(iter);
     } else {
          ++iter;
     }
}

Lo que tenía originalmente incrementaría el iterador dos veces si borrara un elemento de él; potencialmente podría omitir elementos que deben borrarse.

Este es un algoritmo común que he visto utilizado y documentado en muchos lugares.

[EDITAR] Tiene razón en que los iteradores se invalidan después de un borrado, pero solo los iteradores que hacen referencia al elemento que se borra, otros iteradores siguen siendo válidos. Por lo tanto, usar iter++en la erase()llamada.

erase_if para std :: map (y otros contenedores)

Utilizo la siguiente plantilla para esto mismo.

namespace stuff {
  template< typename ContainerT, typename PredicateT >
  void erase_if( ContainerT& items, const PredicateT& predicate ) {
    for( auto it = items.begin(); it != items.end(); ) {
      if( predicate(*it) ) it = items.erase(it);
      else ++it;
    }
  }
}

Esto no devolverá nada, pero eliminará los elementos del std :: map.

Ejemplo de uso:

// 'container' could be a std::map
// 'item_type' is what you might store in your container
using stuff::erase_if;
erase_if(container, []( item_type& item ) {
  return /* insert appropriate test */;
});

Segundo ejemplo (le permite pasar un valor de prueba):

// 'test_value' is value that you might inject into your predicate.
// 'property' is just used to provide a stand-in test
using stuff::erase_if;
int test_value = 4;  // or use whatever appropriate type and value
erase_if(container, [&test_value]( item_type& item ) {
  return item.property < test_value;  // or whatever appropriate test
});

Ahora, std::experimental::erase_ifestá disponible en header <experimental/map>.

Ver: http://en.cppreference.com/w/cpp/experimental/map/erase_if

Obtuve esta documentación de la excelente referencia SGI STL :

Map tiene la propiedad importante de que insertar un nuevo elemento en un mapa no invalida los iteradores que apuntan a elementos existentes. Borrar un elemento de un mapa tampoco invalida ningún iterador, excepto, por supuesto, para los iteradores que realmente apuntan al elemento que se está borrando.

Por lo tanto, el iterador que tiene que apunta al elemento que se va a borrar, por supuesto, se invalidará. Haz algo como esto:

if (some condition)
{
  iterator here=iter++;
  aMap.erase(here)
}

El código original tiene un solo problema:

for(; iter != endIter; ++iter)
{
    if(Some Condition)
    {
        // is it safe ?
        aMap.erase(iter++);
    }
}

Aquí iterse incrementa una vez en el ciclo for y otra vez en el borrado, lo que probablemente terminará en un ciclo infinito.

Aquí tienes una solución elegante.

for (auto it = map.begin(); it != map.end();)
{   
    (SomeCondition) ? map.erase(it++) : (++it);
}

De las notas inferiores de:

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

un contenedor asociativo de pares no puede proporcionar iteradores mutables (como se define en los requisitos del iterador trivial), porque el tipo de valor de un iterador mutable debe ser asignable y el par no es asignable. Sin embargo, un contenedor asociativo de pares puede proporcionar iteradores que no son completamente constantes: iteradores tales que la expresión (* i) .second = d sea válida.

primero

Map tiene la propiedad importante de que insertar un nuevo elemento en un mapa no invalida los iteradores que apuntan a elementos existentes. Borrar un elemento de un mapa tampoco invalida ningún iterador, excepto, por supuesto, los iteradores que realmente apuntan al elemento que se está borrando.

En segundo lugar, el siguiente código es bueno

for(; iter != endIter; )
{
    if(Some Condition)
    {
        aMap.erase(iter++);
    }
    else
    {
        ++iter;
    }
}

Al llamar a una función, los parámetros se evalúan antes de la llamada a esa función.

Entonces, cuando iter ++ se evalúa antes de la llamada a borrar, el operador ++ del iterador devolverá el elemento actual y apuntará al siguiente elemento después de la llamada.

En mi humilde opinión, no hay remove_if()equivalente.
No puede reordenar un mapa.
Así remove_if()que no puedes poner tus pares de interés al final al que puedes llamar erase().

Basado en la respuesta de Iron Savior Para aquellos que deseen proporcionar un rango más similar a los iteradores de toma funcionales estándar.

template< typename ContainerT, class FwdIt, class Pr >
void erase_if(ContainerT& items, FwdIt it, FwdIt Last, Pr Pred) {
    for (; it != Last; ) {
        if (Pred(*it)) it = items.erase(it);
        else ++it;
    }
}

Es curioso si hay alguna forma de perder los ContainerTelementos y obtenerlos del iterador.

La respuesta de Steve Folly me siento más eficiente.

Aquí hay otra solución fácil pero menos eficiente :

La solución usa remove_copy_ifpara copiar los valores que queremos en un nuevo contenedor, luego intercambia el contenido del contenedor original con los del nuevo:

std::map<int, std::string> aMap;

...
//Temporary map to hold the unremoved elements
std::map<int, std::string> aTempMap;

//copy unremoved values from aMap to aTempMap
std::remove_copy_if(aMap.begin(), aMap.end(), 
                    inserter(aTempMap, aTempMap.end()),
                    predicate);

//Swap the contents of aMap and aTempMap
aMap.swap(aTempMap);

Si desea borrar todos los elementos con clave mayor que 2, entonces la mejor manera es

map.erase(map.upper_bound(2), map.end());

Sin embargo, solo funciona para rangos, no para ningún predicado.

Yo uso así

 std::map<int, std::string> users;    
 for(auto it = users.begin(); it <= users.end()) {
    if(<condition>){
      it = users.erase(it);
    } else {
    ++it;
    }
 }