std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: operator[]

Devuelve una referencia al valor que está mapeado a una clave equivalente a key o x respectivamente, realizando una inserción si dicha clave no existe previamente.

Si después de la operación el nuevo número de elementos es mayor que el antiguo max_load_factor() * bucket_count() se produce una redistribución.
Si ocurre redistribución (debido a la inserción), todos los iteradores quedan invalidados. En caso contrario (sin redistribución), los iteradores no se invalidan.

Parámetros

Valor de retorno

Excepciones

Si se lanza una excepción por cualquier operación, la inserción no tiene efecto.

Complejidad

Caso promedio: constante, caso peor: lineal en tamaño.

Notas

En los estándares publicados de C++11 y C++14, esta función se especificaba como requerir que mapped_type fuera DefaultInsertable y que key_type fuera CopyInsertable o MoveInsertable en * this . Esta especificación era defectuosa y fue corregida por LWG issue 2469 , y la descripción anterior incorpora la resolución de ese issue.

Sin embargo, se sabe que una implementación (libc++) construye los objetos key_type y mapped_type mediante dos llamadas separadas al allocator construct() , como posiblemente requieren los estándares publicados, en lugar de emplacear un objeto value_type .

operator [ ] no es constante porque inserta la clave si no existe. Si este comportamiento no es deseable o si el contenedor es const , at puede ser utilizado.

Ejemplo

#include <iostream>
#include <string>
#include <unordered_map>
void println(auto const comment, auto const& map)
{
    std::cout << comment << '{';
    for (const auto& pair : map)
        std::cout << '{' << pair.first << ": " << pair.second << '}';
    std::cout << "}\n";
}
int main()
{
    std::unordered_map<char, int> letter_counts{{'a', 27}, {'b', 3}, {'c', 1}};
    println("letter_counts initially contains: ", letter_counts);
    letter_counts['b'] = 42; // actualiza un valor existente
    letter_counts['x'] = 9;  // inserta un nuevo valor
    println("after modifications it contains: ", letter_counts);
    // contar el número de ocurrencias de cada palabra
    // (la primera llamada a operator[] inicializa el contador con cero)
    std::unordered_map<std::string, int>  word_map;
    for (const auto& w : {"this", "sentence", "is", "not", "a", "sentence",
                          "this", "sentence", "is", "a", "hoax"})
        ++word_map[w];
    word_map["that"]; // simplemente inserta el par {"that", 0}
    for (const auto& [word, count] : word_map)
        std::cout << count << " occurrence(s) of word '" << word << "'\n";
}

letter_counts initially contains: {{a: 27}{b: 3}{c: 1}}
after modifications it contains: {{a: 27}{b: 42}{c: 1}{x: 9}}
2 occurrence(s) of word 'a'
1 occurrence(s) of word 'hoax'
2 occurrence(s) of word 'is'
1 occurrence(s) of word 'not'
3 occurrence(s) of word 'sentence'
0 occurrence(s) of word 'that'
2 occurrence(s) of word 'this'

Véase también