Namespaces
Variants

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

From cppreference.net

T & operator [ ] ( const Key & key ) ;
(1) (depuis C++23)
T & operator [ ] ( Key && key ) ;
(2) (depuis C++23)
template < class K >
T & operator [ ] ( K && x ) ;
(3) (depuis C++23)

Retourne une référence à la valeur qui est mappée à une clé équivalente à key ou x respectivement, en effectuant une insertion si une telle clé n'existe pas déjà.

1) Insère un objet value_type construit en place si la clé n'existe pas. Équivalent à return try_emplace ( x ) . first - > second ; .
2) Insère un objet value_type construit en place si la clé n'existe pas. Équivalent à return try_emplace ( std :: move ( x ) ) . first - > second ;
3) Insère un objet value_type construit en place s'il n'existe aucune clé qui compare de manière transparente équivalente à la valeur x .
Équivalent à return this - > try_emplace ( std:: forward < K > ( x ) ) . first - > second ; . Cette surcharge participe à la résolution de surcharge uniquement si Compare est transparent . Elle permet d'appeler cette fonction sans construire une instance de Key .

Table des matières

Paramètres

key - la clé de l'élément à trouver
x - une valeur de type quelconque pouvant être comparée de manière transparente avec une clé

Valeur de retour

1,2) Une référence à la valeur mappée du nouvel élément si aucun élément avec la clé key n'existait. Sinon, une référence à la valeur mappée de l'élément existant dont la clé est équivalente à key .
3) Une référence à la valeur mappée du nouvel élément si aucun élément avec une clé équivalente à la valeur x n'existait. Sinon, une référence à la valeur mappée de l'élément existant dont la clé est équivalente à x .

Exceptions

Si une exception est levée par une opération quelconque, l'insertion n'a aucun effet.

Complexité

Logarithmique par rapport à la taille du conteneur, plus le coût de insertion (le cas échéant) d'un élément vide.

Notes

operator [ ] n'est pas constant car il insère la clé si elle n'existe pas. Si ce comportement est indésirable ou si le conteneur est const , at peut être utilisé.

insert_or_assign renvoie plus d'informations que operator [ ] et ne nécessite pas la constructibilité par défaut du type mappé.

Exemple

#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; // met à jour une valeur existante
    letter_counts['x'] = 9;  // insère une nouvelle valeur
    println("after modifications it contains: ", letter_counts);
    // compte le nombre d'occurrences de chaque mot
    // (le premier appel à operator[] initialise le compteur à zéro)
    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"]; // insère simplement la paire {"that", 0}
    for (const auto& [word, count] : word_map)
        std::cout << count << " occurrence(s) of word '" << word << "'\n";
}

Sortie :

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'

Voir aussi

accéder à l'élément spécifié avec vérification des limites
(fonction membre publique)
insère un élément ou assigne à l'élément courant si la clé existe déjà
(fonction membre publique)
insère en place si la clé n'existe pas, ne fait rien si la clé existe
(fonction membre publique)