std::map<Key,T,Compare,Allocator>::operator[]
T& operator[]( const Key& key ); |
(1) | |
T& operator[]( Key&& key ); |
(2) | (desde C++11) |
Devuelve una referencia al valor que corresponde al elemento con clave equivalente a key, realizando una inserción si tal clave no existe.
|
1) Inserta value_type(key, T()) si la clave no existe. Esta función es equivalente a return insert(std::make_pair(key, T())).first->second;
|
(hasta C++11) | ||||||
|
1) Inserta un objeto
value_type construido en el sitio a partir de std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() si la clave no existe. Esta función es equivalente a return this->try_emplace(key).first->second;. (desde C++17) Cuando se utiliza el asignador de memoria por defecto, esto da como resultado que la clave se construya por copia de key y el valor correspondiente sea inicializado por valor.
2) Inserta un objeto value_type construido en el sitio a partir de std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() si la clave no existe. Esta función es equivalente a return this->try_emplace(std::move(key)).first->second;. (desde C++17) Cuando se utiliza el asignador de memoria por defecto, esto da como resultado que la clave se construya por movimiento de key y el valor correspondiente sea inicializado por valor.
|
(desde C++11) | ||||||
No se invalidan ni referencias ni iteradores.
Parámetros
| key | - | La clave del elemento a encontrar. |
Valor de retorno
Una referencia al valor correspondiente del nuevo elemento solicitado si no existía ningún elemento con la clave key. De lo contrario, una referencia al valor correspondiente del elemento existente cuya clave es equivalente a la clave key.
Excepciones
Si alguna operación lanza una excepción, la inserción no tiene ningún efecto.
Complejidad
Logarithmic in the size of the container.
Notas
En los estándares publicados de C++11 y C++14, esta función se especificó para requerir que mapped_type sea DefaultInsertable y key_type sea CopyInsertable o MoveInsertable en *esta. Esta especificación era defectuosa y fue corregida por Asunto LWG 2469, y la descripción anterior incorpora la resolución de ese asunto.
Sin embargo, se sabe que una implementación (libc++) construye los objetos key_type y mapped_type a través de dos llamadas de asignador construct() separadas, como posiblemente lo requieran los estándares como se han publicado, en lugar de colocar un objeto value_type.
operator[] no es const porque inserta la clave si no existe. Si este comportamiento no es deseable o si el contenedor es const, se puede usar at().
|
|
(desde C++17) |
Ejemplo
#include <iostream>
#include <string>
#include <map>
auto imprimir = [](auto const comentario, auto const& map) {
std::cout << comentario << "{";
for (const auto &pair : map) {
std::cout << "{" << pair.first << ": " << pair.second << "}";
}
std::cout << "}\n";
};
int main()
{
std::map<char, int> conteo_de_letras {{'a', 27}, {'b', 3}, {'c', 1}};
imprimir("conteo_de_letras inicialmente contiene: ", conteo_de_letras);
conteo_de_letras['b'] = 42; // actualiza un valor existente
conteo_de_letras['x'] = 9; // inserta un valor nuevo
imprimir("después de las modificaciones: ", conteo_de_letras);
// cuenta el número de ocurrencias de cada palabra
// (la primera llamada a operator[] inicializó el contador a cero)
std::map<std::string, int> map_de_palabras;
for (const auto &w : { "esta", "oración", "no", "es", "una", "oración",
"esta", "oración", "es", "una", "broma"}) {
++map_de_palabras[w];
}
map_de_palabras["esa"]; // justo inserta el par {"esa", 0}
for (const auto &[palabra, cuenta] : map_de_palabras) {
std::cout << cuenta << " ocurrencias de la palabra '" << palabra << "'\n";
}
}
Salida:
conteo_de_letras inicialmente contiene: {{a: 27}{b: 3}{c: 1}}
después de las modificaciones: {{a: 27}{b: 42}{c: 1}{x: 9}}
2 ocurrencias de la palabra 'una'
1 ocurrencias de la palabra 'broma'
2 ocurrencias de la palabra 'es'
1 ocurrencias de la palabra 'no'
3 ocurrencias de la palabra 'oración'
0 ocurrencias de la palabra 'esa'
2 ocurrencias de la palabra 'esta'
Véase también
(C++11) |
Accede al elemento especificado con comprobación de límites. (función miembro pública) |
(C++17) |
Inserta un elemento o asigna el elemento actual si la clave ya existe. (función miembro pública) |
(C++17) |
Inserta en el sitio si la clave no existe; no hace nada si la clave existe. (función miembro pública) |