En los mapas STL, ¿es mejor usar map :: insert que []?

Hace un tiempo, tuve una discusión con un colega sobre cómo insertar valores en los mapas STL . Preferí map[key] = value; porque se siente natural y es claro de leer, mientras que él prefirió map.insert(std::make_pair(key, value))

Simplemente le pregunté y ninguno de nosotros puede recordar la razón por la cual insertar es mejor, pero estoy seguro de que no fue solo una preferencia de estilo, sino que hubo una razón técnica como la eficiencia. La referencia de SGI STL simplemente dice "Estrictamente hablando, esta función miembro es innecesaria: existe solo por conveniencia".

¿Alguien puede decirme esa razón, o solo estoy soñando que hay una?

Cuando escribes

map[key] = value;

no hay forma de saber si reemplazaste el valuefor keyo si creaste uno nuevo keycon value.

map::insert() solo creará:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

Para la mayoría de mis aplicaciones, generalmente no me importa si estoy creando o reemplazando, por lo que utilizo el más fácil de leer map[key] = value.

Los dos tienen una semántica diferente cuando se trata de la clave que ya existe en el mapa. Entonces no son realmente directamente comparables.

Pero la versión del operador [] requiere la construcción predeterminada del valor y luego la asignación, por lo que si esto es más costoso que copiar la construcción, entonces será más costoso. A veces, la construcción predeterminada no tiene sentido, y entonces sería imposible usar la versión del operador [].

Otra cosa a tener en cuenta std::map :

myMap[nonExistingKey]; creará una nueva entrada en el mapa, clave para nonExistingKey inicializada a un valor predeterminado.

Esto me asustó muchísimo la primera vez que lo vi (mientras me golpeaba la cabeza contra un desagradable error heredado). No lo hubiera esperado. Para mí, eso parece una operación de obtención, y no esperaba el "efecto secundario". Prefiere map.find()cuando salgas de tu mapa.

Si el éxito del constructor predeterminado no es un problema, por favor, por amor de Dios, ve con la versión más legible.

:)

insert es mejor desde el punto de excepción la seguridad.

La expresión map[key] = valuees en realidad dos operaciones:

1. map[key] - Crear un elemento de mapa con valor predeterminado.
2. = value - copiando el valor en ese elemento.

Puede ocurrir una excepción en el segundo paso. Como resultado, la operación se realizará solo parcialmente (se agregó un nuevo elemento al mapa, pero ese elemento no se inicializó con value). La situación cuando una operación no está completa, pero se modifica el estado del sistema, se llama operación con "efecto secundario".

insertLa operación ofrece una garantía sólida, lo que significa que no tiene efectos secundarios ( https://en.wikipedia.org/wiki/Exception_safety ). insertestá completamente hecho o deja el mapa en estado no modificado.

http://www.cplusplus.com/reference/map/map/insert/ :

Si se inserta un solo elemento, no hay cambios en el contenedor en caso de excepción (garantía sólida).

Si su aplicación es crítica para la velocidad, aconsejaré usar el operador [] porque crea un total de 3 copias del objeto original, de las cuales 2 son objetos temporales y tarde o temprano se destruyen como.

Pero en insert (), se crean 4 copias del objeto original de las cuales 3 son objetos temporales (no necesariamente "temporales") y se destruyen.

Lo que significa tiempo extra para: 1. Una asignación de memoria de objetos 2. Una llamada de constructor adicional 3. Una llamada de destructor adicional 4. Una desasignación de memoria de objetos

Si sus objetos son grandes, los constructores son típicos, los destructores liberan muchos recursos, los puntos anteriores cuentan aún más. En cuanto a la legibilidad, creo que ambos son lo suficientemente justos.

La misma pregunta vino a mi mente pero no sobre la legibilidad sino la velocidad. Aquí hay un código de muestra a través del cual llegué a conocer el punto que mencioné.

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

Ahora en c ++ 11 creo que la mejor manera de insertar un par en un mapa STL es:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

El resultado será un par con:

• Primer elemento (resultado.primero), apunta al par insertado o apunta al par con esta clave si la clave ya existe.

• Segundo elemento (resultado.segundo), verdadero si la inserción fue correcta o falsa, algo salió mal.

PD: Si no tiene dudas sobre el orden, puede usar std :: unordered_map;)

¡Gracias!

Un problema con map :: insert () es que no reemplazará un valor si la clave ya existe en el mapa. He visto código C ++ escrito por programadores de Java donde esperaban que insert () se comportara de la misma manera que Map.put () en Java, donde se reemplazan los valores.

Una nota es que también puedes usar Boost.Assign :

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

Aquí hay otro ejemplo, que muestra que operator[] sobrescribe el valor de la clave si existe, pero .insert no sobrescribe el valor si existe.

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

Este es un caso bastante restringido, pero a juzgar por los comentarios que he recibido, creo que vale la pena señalarlo.

He visto personas en el pasado usar mapas en forma de

map< const key, const val> Map;

para evadir casos de sobreescritura accidental de valores, pero luego seguir escribiendo otros bits de código:

const_cast< T >Map[]=val;

Recuerdo que su razón para hacerlo fue porque estaban seguros de que en estos ciertos bits de código no iban a sobrescribir los valores del mapa; por lo tanto, seguir adelante con el método más 'legible'[] .

En realidad, nunca he tenido ningún problema directo con el código que escribieron estas personas, pero hasta ahora creo firmemente que los riesgos, por pequeños que sean, no deberían tomarse cuando pueden evitarse fácilmente.

En los casos en que se trate de valores de mapas que no se deben sobrescribir, use insert. No haga excepciones simplemente por legibilidad.

El hecho de que la función std :: map insert()no sobrescribe el valor asociado con la clave nos permite escribir un código de enumeración de objetos como este:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

Es un problema bastante común cuando necesitamos asignar diferentes objetos no únicos a algunas identificaciones en el rango 0..N. Esos id se pueden usar más tarde, por ejemplo, en algoritmos de gráficos. La alternativa con operator[]parecería menos legible en mi opinión:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}