¿Cuál es la diferencia entre el operador de sobrecarga de índice y el método de inserción llamado para std :: map?std :: diferencia de mapa entre llamadas de inserción e índice
es decir:
some_map["x"] = 500;
vs.
some_map.insert(pair<std::string, int>("x", 500));
I creen insertar() no sobrescribir un valor existente, y el resultado de la operación se puede comprobar mediante el ensayo del valor bool en el valor iterador/pair regresaron
La asignación al operador subíndice [] simplemente sobrescribe lo que está allí (insertando una entrada si ya no hay ninguna)
Cualquiera de los operadores de inserción y [] puede causar problemas si no está esperando ese comportamiento y no lo acomoda.
por ejemplo, con inserción:
std::map< int, std::string* > intMap;
std::string* s1 = new std::string;
std::string* s2 = new std::string;
intMap.insert(std::make_pair(100, s1)); // inserted
intMap.insert(std::make_pair(100, s2)); // fails, s2 not in map, could leak if not tidied up
y con el operador []:
std::map< int, std::string* > intMap;
std::string* s1 = new std::string;
std::string* s2 = new std::string;
intMap[ 100 ] = s1; // inserted
intMap[ 100 ] = s2; // inserted, s1 now dropped from map, could leak if not tidied up
creo que esas son correctos, pero no los han recopilado, por lo que puede tener errores de sintaxis
El método de inserción se inserta en el mapa, mientras que el operador de índice sobrecargado devolverá el elemento con el key_value clave si se encuentra en el mapa, si no está ya en el mapa, lo insertará.
Solo se insertará en el mapa si una clave determinada no está presente. Si está presente, insert() no actualizará el valor mientras que una asignación al operador [] lo hará. –
Para un map, la expresión anterior (operator[]) siempre reemplazará la parte del valor del par clave-valor con el nuevo valor suministrado. Se insertará un nuevo par clave-valor si aún no existe uno.
Por el contrario, insert solo insertará un nuevo par de clave-valor si un par de clave-valor con la parte clave suministrada no existe en el mapa.
Además del hecho de que map::operator[] reemplazará un valor existente es que operator[] mapa :: será crear y añadir al mapa un valor predeterminado existente para reemplazar antes de que ocurra la sustitución (la llamada map::operator[]() tiene que devolver una referencia a algo). Para los artículos que son caros de crear, esto podría ser un problema de rendimiento.
Consulte "Artículo 24: Elija cuidadosamente entre map::operator[] y map::insert cuando la eficiencia es importante" en Scott Meyers' Effective STL.
El primero es mucho más legible;) – schnaader
El uso de make_pair() ayudaría en la inserción porque puede deducir los tipos de argumento: "some_map.insert (std :: make_pair (" x ", 500));" –
@Fred Larson: aunque el 'make_pair' que se muestra deduciría' const char * 'y' int', por lo que se generará una conversión implícita de un 'par' al real' value_type' del 'map'. –