Maîtriser std::map en C++ : Guide complet avec exemples de code

Qu'est-ce que std::map ?

Dans la bibliothèque de modèles standard (STL) C++, std::map est un conteneur associatif qui stocke les éléments sous forme de paires clé-valeur. Chaque clé est unique et le conteneur maintient automatiquement les éléments triés selon la fonction de comparaison de la clé (par défaut, std::less). Les valeurs peuvent être de tout type et sont accessibles via leurs clés correspondantes.

Pourquoi utiliser std::map ?

• Les clés sont uniques et stockées dans l'ordre trié, rendant les opérations de recherche rapides (O(log n)).
• Idéal pour les scénarios nécessitant un tableau associatif ou dictionnaire avec ordre garanti.
• Implémenté en interne comme un arbre de recherche binaire équilibré (arbre rouge-noir), offrant une performance fiable pour toutes les opérations.
• Supporte l'insertion, la suppression et le parcours rapides.
• API riche qui s'intègre parfaitement avec les itérateurs et les algorithmes STL.

Syntaxe

Déclarez un map avec :

std::map<TypeCle, TypeValeur> nomMap;

• TypeCle – le type de la clé (doit être comparable).
• TypeValeur – le type de la valeur associée.
• nomMap – le nom de la variable.

Exemple :

std::map<std::string, int> ageMap;

Types membres

• key_type : Type des clés.
• mapped_type : Type des valeurs mappées.
• value_type : std::pair<const key_type, mapped_type>
• iterator : Itérateur bidirectionnel sur value_type.
• const_iterator, reverse_iterator, const_reverse_iterator
• size_type, difference_type

Fonctions intégrées

• begin() – itérateur vers le premier élément.
• end() – itérateur après la fin.
• size() – nombre d'éléments.
• empty() – si le map est vide.
• insert() – ajoute une paire clé/valeur.
• find() – localise un élément par clé.
• erase() – supprime des éléments par itérateur ou clé.
• clear() – supprime tous les éléments.
• D'autres utilitaires comme count() et lower_bound() sont aussi disponibles.

Itérer sur les éléments du map

Les itérateurs donnent un contrôle total sur l'ordre de parcours, qui est toujours trié par clé.

#include <iostream>
#include <string>
#include <map>
using namespace std;
int main() {
    map<int, string> students;
    students.insert({200, "Alice"});
    students.insert({201, "John"});
    cout << "Map size is: " << students.size() << endl;
    cout << endl << "Default map order:" << endl;
    for (auto it = students.begin(); it != students.end(); ++it) {
        cout << it->first << ": " << it->second << endl;
    }
    return 0;
}

Sortie :

Insérer des données dans std::map

Utilisez insert() pour de nouvelles entrées ; il rejette silencieusement les doublons. Pour écraser une clé existante, utilisez insert_or_assign().

#include <map>
#include <iostream>
using namespace std;
int main() {
    map<int, int> m{{1,3},{2,4},{3,5}};
    m.insert({5,6}); // ajoute nouvelle paire
    m.insert({1,8}); // ignoré, clé 1 existe déjà
    m.insert_or_assign(1,6); // met à jour clé 1 à valeur 6
    cout << "Key\tElement\n";
    for (auto& p : m) {
        cout << p.first << '\t' << p.second << '\n';
    }
    return 0;
}

Sortie :

Rechercher dans un map

Trouver une clé est simple avec find(). Si la clé existe, l'itérateur retourné pointe vers l'élément ; sinon end() est retourné.

#include <iostream>
#include <map>
using namespace std;
int main() {
    map<int, string> students;
    students.insert({200, "Alice"});
    students.insert({201, "John"});
    if (auto it = students.find(201); it != students.end()) {
        cout << "Key 201 has value: " << it->second << endl;
    }
    return 0;
}

Sortie :

Supprimer des données d'un map

Les éléments peuvent être supprimés par clé ou par itérateur. La méthode erase() invalide seulement les itérateurs pointant vers l'élément effacé.

#include <iostream>
#include <map>
using namespace std;
int main() {
    map<string, int> myMap;
    myMap["cow"] = 1;
    myMap["cat"] = 2;
    myMap["lion"] = 3;
    if (auto it = myMap.find("cat"); it != myMap.end()) {
        myMap.erase(it);
    }
    for (auto& p : myMap) {
        cout << p.first << ": " << p.second << endl;
    }
    return 0;
}

Sortie :

Résumé

• std::map est un conteneur associatif trié avec clés uniques.
• Les clés fournissent une recherche efficace ; les valeurs contiennent les données associées.
• Toutes les opérations de base s'exécutent en temps logarithmique grâce à l'arbre rouge-noir sous-jacent.
• Les itérateurs permettent le parcours, l'insertion, la suppression et les requêtes de plage.
• Avec insert_or_assign(), la mise à jour des valeurs est simple.
• Utilisez find() pour des vérifications d'existence rapides et un accès direct.
• Les opérations d'effacement peuvent cibler des éléments individuels ou vider tout le map.