Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies.


Politique de confidentialité
Introduction et syntaxe de base
Pointeurs et fonctions
Programmation OO
Structures de données
La bibliothèque standard (STL)

Les dictionnaires en C++ : Classe map (Bibliothèque STL)

 

Les dictionnaires en C++ : Classe map (Bibliothèque STL)

La classe map, qui est également appelée dictionnaire ou tableau associé, est définie dans le fichier d'en-tête <map>. C'est un conteneur qui stocke une paire de clé et de valeur, deux valeurs mappées ne peuvent pas partager les mêmes valeurs de clé. Les éléments sont triés par ordre croissant en fonction de la clé. Dans un dictionnaire, les clés sont uniques.

En interne, les conteneurs map conservent tous leurs éléments triés. Les éléments sont toujours insérés dans leur position respective en suivant cet ordre.

Les valeurs clés servent à trier et à identifier les éléments de manière unique. Les valeurs mappées servent à stocker le contenu associé à la clé. Les deux peuvent être de types différents, mais le type membre pair les combine.

La classe map est implémentée en utilisant des arbres binaires de recherche équilibrés.
Syntaxe
std::map<type_cle, val_type> nomMap; 
  •  type_cle dénote le type de données des clés de dictionnaire.
  •  type_valeur indique le type de données des valeurs correspondant aux clés de dictionnaire.
  •  nomMap est le nom de dictionnaire.
Exemple
map<string, int> dict1; 

Nous avons déclaré ici un dictionnaire nommé dict1. Le dictionnaire aura une chaîne de caractères comme types de données pour les clés et un entier comme type de données pour les valeurs.

Opérations

Les opérations définies pour la classe map sont très similaires à celles de la classe set. La principale différence est la possibilité d'accéder aux éléments du dictionnaire à l'aide de l'opérateur [ ]. Cet opérateur fait ressembler un objet map à un tableau dans lequel l'index est une valeur clé au lieu d'un entier. En d'autres termes, si nous connaissons la valeur de la clé dans un élément, nous pouvons accéder à l'élément en utilisant l'expression nomMap[clé]. Cependant, l'opérateur [ ] n'agit pas comme celui utilisé pour un tableau ou un vecteur ou un deque. C'est juste une notation pour créer une paire composée de clé-valeur. Un dictionnaire n'utilise que des itérateurs bidirectionnels et ne peut pas sauter d'une paire à une autre à l'aide de l'opérateur + ou -.

Taille

Il existe trois fonctions membres dans la classe map que nous pouvons utiliser pour vérifier la taille, la taille maximale et le vide. Elles sont les mêmes que celles discutées pour les conteneurs de séquence.

SyntaxeDescription
dict1.size(); Renvoie la taille actuelle
dict1.max_size(); Renvoie la taille maximale
dict1.empty(); Renvoie true si le dictionnaire dict1 est vide
Accéder aux éléments
operateur []

Si k correspond à la clé d'un élément du conteneur, la fonction renvoie une référence à sa valeur mappée.

Si k ne correspond à la clé d'aucun élément du conteneur, la fonction insère un nouvel élément avec cette clé et renvoie une référence à sa valeur mappée. Notez que cette fonction augmente toujours la taille du conteneur de 1, même si aucune valeur mappée n'est assignée à l'élément (l'élément est construit en utilisant son constructeur par défaut).

map::at

Renvoie une référence à la valeur mappée de l'élément identifié par la clé k.

Si k ne correspond à la clé d'aucun élément du conteneur, la fonction lève une exception out_of_range.

Insertion

Étend le conteneur en insérant de nouveaux éléments, augmentant effectivement la taille du conteneur du nombre d'éléments insérés.

Les clés des éléments d'un dictionnaire étant uniques, l'opération d'insertion vérifie si chaque élément inséré possède une clé équivalente à celle d'un élément déjà présent dans le conteneur. Si tel est le cas, l'élément n'est pas inséré et renvoie un itérateur vers cet élément existant.

Une autre façon d'insérer des éléments dans un dictionnaire est d'utiliser la fonction membre map::operator[].
iterator map_name.insert({clé, élément})

La fonction accepte une paire composée d'une clé et d'un élément qui doit être inséré dans le conteneur map. La fonction n'insère pas la clé et l'élément dans le dictionnaire si la clé existe déjà dans le dictionnaire. La fonction renvoie un itérateur pointant vers le nouvel élément dans le conteneur.

iterator map_name.insert(iterator position, { clé, élément })

La fonction accepte deux paramètres qui sont décrits ci-dessous :

  •  {clé, élément} : Ceci spécifie une paire composée d'une clé et d'un élément qui doit être inséré dans le conteneur map (dictionnaire).
  •  position : Ce paramètre ne spécifie pas la position où l'insertion doit être effectuée, il indique seulement une position à partir de laquelle l'opération de recherche pour l'insertion doit être lancée pour accélérer le processus. L'insertion est effectuée selon l'ordre suivi par le conteneur map.
iterator map_name.insert(iterator position1, iterator position2)

La fonction accepte deux paramètres position1 et position2 qui spécifient la plage d'éléments. Tous les éléments de la plage [position1, position2] sont insérés dans un autre conteneur map. La fonction renvoie un itérateur pointant sur le nouvel élément dans le conteneur.

Itérateurs

La classe map utilise des itérateurs bidirectionnels (et non à accès aléatoire). Elle fournit les mêmes huit itérateurs internes que les conteneurs de séquence, dont quatre sont constants et quatre non constants. Les itérateurs constants et non constants ont la même syntaxe.

SyntaxeDescription
dict1.begin()Retourne un itérateur régulier au premier élément
dict1.end()Renvoie un itérateur régulier à l'élément après le dernier
dict1.rbegin()Retourne un itérateur inverse au dernier élément
dict1.rend()Renvoie un itérateur inverse à l'élément avant le premier
Rechercher dans un dictionnaire

Comme classe map utilise un arbre binaire de recherche équilibré pour stocker les éléments, la recherche est possible et efficace. Il y a cinq membres pour la recherche, comme indiqué ci-dessous :

SyntaxeDescription
dict1.count(k)Renvoie le nombre d'éléments égal à k
dict1.find(k)Retourne un itérateur pointant sur le premier k trouvé
dict1.lower_bound(k)Renvoie la première position où k peut être inséré
dict1.upper_bound(k)Renvoie la dernière position où k peut être inséré
dict1.equal_range(k)Combinaison de limite inférieure et supérieure
Supprimer des éléments

La suppression d'éléments doit se faire par le biais de la clé ou de l'itérateur.

SyntaxeDescription
dict1.erase(k) Supprime k
dict1.erase(pos) Supprimer un élément pointé par pos
dict1.erase(premier, dernier)Supprimer les éléments de la plage [premier, dernier)
dict1.clear() Vider le dictionnaire

Exemple complet

#include <iostream>
#include <map>

using namespace std;

void afficher(map <string,float> dict1)
{
    map<string,float>::iterator it;
    for (it = dict1.begin (); it != dict1.end(); it++)
    {
        cout << it->first << " ";
        cout << it-> second << '\n';
    }
    cout << "\n";
}

int main() {
    map<string,float> dict1;

    dict1["Ismail"]=10.5;
    dict1["Sara"]=17.5;
    dict1["Omar"]=8.5;
    dict1.insert({"Alex",14});
    dict1.insert({"Moneim",10});

    cout<< "Nombre d'elements dans dict1 : "<<dict1.size()<<'\n';

    cout<<"Les elements de l'ensemble  : "<< '\n';
    afficher(dict1);

    dict1["Sara"]=13.25; // modifier la note de sara
    

    dict1.erase("Omar");
    cout<<"Les elements de l'ensemble apres suppression : "<< '\n';
    afficher(dict1);

    return 0;
}
        
Nombre d'elements dans dict1 : 5
Les elements de l'ensemble  :
Alex 14
Ismail 10.5
Moneim 10
Omar 8.5
Sara 17.5

Les elements de l'ensemble apres suppression :
Alex 14
Ismail 10.5
Moneim 10
Sara 13.25
                

Partager ce cours avec tes amis :
Rédigé par ESSADDOUKI Mostafa
ESSADDOUKI
The education of the 21st century opens up opportunities to not merely teach, but to coach, mentor, nurture and inspire.