std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::operator[] - cppreference.com

De cppreference.com

`T& operator[]( const Key& key );`	(1)	(desde {std})
`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 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.

La información sobre la invalidación del iterador se copia de aquí

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

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().

insert_or_assign() devuelve más información que operator[] y no requiere la constructibilidad por defecto del tipo correspondiente.

(desde C++17)

Ejemplo

#include <iostream>
#include <string>
#include <flat_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::flat_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::flat_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";
    }
}

Posible 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

Accede al elemento especificado con comprobación de límites.
(función miembro pública) [editar]