Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: operator[]

From cppreference.net

C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
T & operator [ ] ( const Key & key ) ;
(1) (desde C++23)
T & operator [ ] ( Key && key ) ;
(2) (desde C++23)
template < class K >
T & operator [ ] ( K && x ) ;
(3) (desde C++23)

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.

1) Inserta un objeto value_type construido in-situ si la clave no existe. Equivalente a return try_emplace ( x ) . first - > second ; .
2) Inserta un objeto value_type construido in-situ si la clave no existe. Equivalente a return try_emplace ( std :: move ( x ) ) . first - > second ;
3) Inserta un objeto value_type construido in-situ si no existe ninguna clave que compare transparentemente equivalente al valor x .
Equivalente a return this - > try_emplace ( std:: forward < K > ( x ) ) . first - > second ; . Esta sobrecarga participa en la resolución de sobrecarga solo si Compare es transparente . Permite llamar a esta función sin construir una instancia de Key .
La información sobre la invalidación de iteradores está copiada de aquí

Contenidos

Parámetros

key - la clave del elemento a buscar
x - un valor de cualquier tipo que puede compararse transparentemente con una clave

Valor de retorno

1,2) Una referencia al valor mapeado del nuevo elemento si no existía ningún elemento con la clave key . De lo contrario, una referencia al valor mapeado del elemento existente cuya clave es equivalente a key .
3) Una referencia al valor mapeado del nuevo elemento si no existía ningún elemento con clave que compare equivalente al valor x . De lo contrario, una referencia al valor mapeado del elemento existente cuya clave compara equivalente a x .

Excepciones

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

Complejidad

Logarítmico en el tamaño del contenedor, más el costo de inserción (si existe) de un elemento vacío.

Notas

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

insert_or_assign devuelve más información que operator [ ] y no requiere que el tipo mapeado sea construible por defecto.

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string>
#include <flat_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::flat_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);
    // cuenta el número de ocurrencias de cada palabra
    // (la primera llamada a operator[] inicializa el contador con cero)
    std::flat_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";
}

Salida: 

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

accede al elemento especificado con verificación de límites
(función miembro pública)
inserta un elemento o asigna al elemento actual si la clave ya existe
(función miembro pública)
inserta in situ si la clave no existe, no hace nada si la clave existe
(función miembro pública)