std:: map

std::map est un conteneur associatif trié qui contient des paires clé-valeur avec des clés uniques. Les clés sont triées en utilisant la fonction de comparaison Compare . Les opérations de recherche, de suppression et d'insertion ont une complexité logarithmique. Les maps sont généralement implémentés comme des arbres rouge-noir .

Les itérateurs de std::map parcourent les éléments dans l'ordre croissant des clés, où l'ordre croissant est défini par la comparaison utilisée lors de la construction. Autrement dit, étant donné

• m , une std::map
• it_l et it_r , des itérateurs déréférençables vers m , avec it_l < it_r .

m. value_comp ( ) ( * it_l, * it_r ) == true (du plus petit au plus grand si on utilise la comparaison par défaut).

Partout où la bibliothèque standard utilise les Compare requirements, l'unicité est déterminée en utilisant la relation d'équivalence. En termes imprécis, deux objets a et b sont considérés équivalents (non uniques) si aucun n'est comparé comme inférieur à l'autre : ! comp ( a, b ) && ! comp ( b, a ) .

std::map satisfait aux exigences de Container , AllocatorAwareContainer , AssociativeContainer et ReversibleContainer .

Paramètres du modèle

Types membres

Classes membres

Fonctions membres

Fonctions non membres

Notes

Exemple

#include <iostream>
#include <map>
#include <string>
#include <string_view>
void print_map(std::string_view comment, const std::map<std::string, int>& m)
{
    std::cout << comment;
    // Itérer en utilisant les fonctionnalités C++17
    for (const auto& [key, value] : m)
        std::cout << '[' << key << "] = " << value << "; ";
// Alternative C++11 :
//  for (const auto& n : m)
//      std::cout << n.first << " = " << n.second << "; ";
//
// Alternative C++98 :
//  for (std::map<std::string, int>::const_iterator it = m.begin(); it != m.end(); ++it)
//      std::cout << it->first << " = " << it->second << "; ";
    std::cout << '\n';
}
int main()
{
    // Créer une map de trois paires (string, int)
    std::map<std::string, int> m{{"CPU", 10}, {"GPU", 15}, {"RAM", 20}};
    print_map("1) Carte initiale : ", m);
    m["CPU"] = 25; // mettre à jour une valeur existante
    m["SSD"] = 30; // insérer une nouvelle valeur
    print_map("2) Carte mise à jour : ", m);
    // L'utilisation de operator[] avec une clé inexistante effectue toujours une insertion
    std::cout << "3) m[UPS] = " << m["UPS"] << '\n';
    print_map("4) Carte mise à jour : ", m);
    m.erase("GPU");
    print_map("5) Après effacement : ", m);
    std::erase_if(m, [](const auto& pair){ return pair.second > 25; });
    print_map("6) Après effacement : ", m);
    std::cout << "7) m.size() = " << m.size() << '\n';
    m.clear();
    std::cout << std::boolalpha << "8) La carte est vide : " << m.empty() << '\n';
}

1) Initial map: [CPU] = 10; [GPU] = 15; [RAM] = 20;
2) Updated map: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30;
3) m[UPS] = 0
4) Updated map: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30; [UPS] = 0;
5) After erase: [CPU] = 25; [RAM] = 20; [SSD] = 30; [UPS] = 0;
6) After erase: [CPU] = 25; [RAM] = 20; [UPS] = 0;
7) m.size() = 3
8) Map is empty: true

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi