Classe et objets
Une classe est un ensemble de variables et de fonctions qui fonctionnent ensemble, où les variables n'ont pas de valeurs affectées. Lorsque des valeurs sont affectées aux variables, la classe devient un objet. Des valeurs différentes attribuées à la même classe donnent des objets différents ; c'est-à-dire que différents objets sont la même classe avec des valeurs différentes. On dit que la création d'un objet à partir d'une classe instancie l'objet.
Le nom, unordered_map, est une classe. Un objet créé à partir de la classe unordered_map a un nom choisi par le programmeur.
Une fonction qui appartient à une classe est nécessaire pour instancier un objet de la classe. En C++, cette fonction a le même nom que le nom de la classe. Les objets créés (instanciés) à partir de la classe ont des noms différents qui leur sont attribués par le programmeur.
Créer un objet à partir de la classe signifie construire l'objet ; cela signifie également instancier.
Un programme C++ qui utilise la classe unordered_map commence par les lignes suivantes en haut du fichier :
#comprendre#comprendre
en utilisant l'espace de noms std;
La première ligne est pour l'entrée/sortie. La deuxième ligne permet au programme d'utiliser toutes les fonctionnalités de la classe unordered_map. La troisième ligne permet au programme d'utiliser les noms dans l'espace de noms standard.
Surcharger une fonction
Lorsque deux signatures de fonction différentes ou plus ont le même nom, ce nom est dit surchargé. Lorsqu'une fonction est appelée, le nombre et le type d'arguments déterminent quelle fonction est réellement exécutée.
Construction/Copie Construction
Construction simple
Une carte non ordonnée peut être construite et affectée des valeurs comme suit :
unordered_map<const carboniser*, const carboniser*>umap;umap['banane'] = 'jaune';
umap['raisin'] = 'vert';
umap['figure'] = 'violet';
La déclaration commence par la spécialisation du modèle avec les types des paires clé et valeur. Ceci est suivi du nom choisi par le programmeur pour la carte ; puis un point-virgule. Le deuxième segment de code montre comment attribuer des valeurs à leurs clés.
Construction par Initializer_list
Cela peut être fait comme suit:
{'raisin', 'vert'}, {'figure', 'violet'}});
Construction en affectant Initializer_list
Exemple:
{'raisin', 'vert'}, {'figure', 'violet'}};
Construction en copiant un autre unordered_map
Exemple:
{'raisin', 'vert'}, {'figure', 'violet'}});
unordered_map<const carboniser*, const carboniser*>umap2(umap1);
La paire Element
Le code suivant montre comment créer et accéder à l'élément pair :
paire<carboniser, const carboniser*>pr= {'ré', 'être'};cout<<pr.premier << ' ';
cout<<pr.seconde << ' ';
La sortie est :
réêtre
premier et deuxième sont des mots réservés pour les deux éléments de la paire. Les valeurs de la paire peuvent toujours être modifiées en utilisant first et second.
Une paire est appelée, value_type dans le sujet de la carte non ordonnée.
Accès aux éléments unordered_map
mapped_type& opérateur[](key_type&& k)
Renvoie la valeur de la clé correspondante. Exemple:
umap['banane'] = 'jaune';
umap['raisin'] = 'vert';
umap['figure'] = 'violet';
const carboniser *droit=umap['raisin'];
cout<<droit<<' ';
La sortie est : verte. Les valeurs peuvent être affectées de la même manière – voir ci-dessus.
unordered_map Capacité
size_type size() const noexcept
Renvoie le nombre de paires dans la carte.
umap['banane'] = 'jaune';
umap['raisin'] = 'vert';
umap['figure'] = 'violet';
cout<<umap.Taille() <<' ';
La sortie est 3.
bool vide() const noexcept
Renvoie 1 pour vrai si la carte n'a pas de paire et 0 pour faux si elle a des paires. Exemple:
unordered_map<const carboniser*, const carboniser*>umap;cout<<umap.vide() <<' ';
La sortie est 1.
Retourner les itérateurs et la classe unordered-map
Un itérateur est comme un pointeur mais a plus de fonctionnalités que le pointeur.
begin() nonsauf
Renvoie un itérateur qui pointe vers la première paire de l'objet map, comme dans le segment de code suivant :
unordered_map<const carboniser*, const carboniser*>umap;umap['banane'] = 'jaune';umap['raisin'] = 'vert';umap['figure'] = 'violet';
unordered_map<const carboniser*, const carboniser*> ::itérateuritérer=umap.commencer();
paire<const carboniser*, const carboniser*>pr= *itérer;
cout<<pr.premier << ',' <<pr.seconde << ' ';
La sortie est : fig, violet. La carte n'est pas ordonnée.
begin() const noexcept;
Renvoie un itérateur qui pointe vers le premier élément de la collection d'objets de carte. Lorsque la construction de l'objet est précédée de const, l'expression begin() const est exécutée au lieu de begin(). Dans cette condition, les éléments de l'objet ne peuvent pas être modifiés. Il est utilisé dans le code suivant, par exemple.
constunordered_map<const carboniser*, const carboniser*>umap({{'banane', 'jaune'},{'raisin', 'vert'}, {'figure', 'violet'}});
unordered_map<const carboniser*, const carboniser*> ::const_iteratoritérer=umap.commencer();
paire<const carboniser*, const carboniser*>pr= *itérer;
cout<<pr.premier << ',' <<pr.seconde << ' ';
La sortie est : fig, violet. La carte n'est pas ordonnée. Notez que const_iterator a été utilisé cette fois, au lieu de simplement iterator, pour recevoir l'itérateur renvoyé.
fin() nonsauf
Renvoie un itérateur qui pointe immédiatement au-delà du dernier élément de l'objet map.
end() const noexcept
Renvoie un itérateur qui pointe immédiatement au-delà du dernier élément de l'objet map. Lorsque la construction de l'objet map est précédée de const, l'expression end() const est exécutée au lieu de end().
Opérations unordered_map
itérateur find(const key_type& k)
Recherche une paire de la clé donnée dans la carte. S'il est trouvé, il renvoie l'itérateur. S'il n'est pas trouvé, il renvoie un itérateur qui pointe vers la fin de la carte, qui n'est pas une paire. Le code suivant montre comment utiliser cette fonction membre :
unordered_map<carboniser,carboniser>umap;umap['à'] = 'b';umap['c'] = 'ré';umap['Et'] = 'F';
unordered_map<carboniser,carboniser> ::itérateuritérer=umap.trouve('c');
si (umap.trouve('c') ! =umap.finir())
{
paire<carboniser,carboniser>pr= *itérer;
cout<<pr.premier << ',' <<pr.seconde << ' ';
}
La sortie est : c, d
const_iterator find(const key_type& k) const;
Cette version de la fonction est appelée, si la création de la carte non ordonnée commence par const, rendant tous les éléments de la carte en lecture seule.
unordered_map Modificateurs
paire insert(value_type&& obj)
Une carte non ordonnée signifie que les paires ne sont dans aucun ordre. Ainsi, le programme insère la paire à n'importe quel endroit qui lui convient. La fonction renvoie, paire. Si l'insertion a réussi, bool sera 1 pour vrai, sinon il serait 0 pour faux. Si l'insertion réussit, l'itérateur pointera sur l'élément nouvellement inséré. Le code suivant illustre l'utilisation :
umap['banane'] = 'jaune';
umap['raisin'] = 'vert';
umap['figure'] = 'violet';
umap.insérer({{'cerise', 'rapporter'}, {'fraise', 'rapporter'}});
cout<<umap.Taille() << ' ';
La sortie est : 5. Plusieurs paires peuvent être insérées.
size_type effacer (const key_type& k)
Cette fonction efface une paire de unordered_map. Le segment de code suivant illustre :
unordered_map<const carboniser*, const carboniser*>umap;umap['banane'] = 'jaune';
umap['raisin'] = 'vert';
umap['figure'] = 'violet';
entiersur une=umap.effacer('raisin');
cout<<umap.Taille() << ' ';
La sortie est 2.
void swap(unordered_map&)
Deux cartes non ordonnées peuvent être échangées, comme illustré dans ce segment de code :
{'raisin', 'vert'}, {'figure', 'violet'}, {'fraise', 'rapporter'}};
unordered_map<const carboniser*, const carboniser*>umap2= {{'cerise', 'rapporter'}, {'chaux', 'vert'}};
umap1.échanger(umap2);
unordered_map<const carboniser*, const carboniser*> ::itérateuriter1=umap1.commencer();
paire<const carboniser*, const carboniser*>pr1= *iter1;
unordered_map<const carboniser*, const carboniser*> ::itérateuriter2=umap2.commencer();
paire<const carboniser*, const carboniser*>pr2= *iter2;
cout<< 'Première clé et taille de umap1 : '<<pr1.premier <<','<<umap1.Taille() << ' ';
cout<< 'Première clé et taille de umap2'<<pr2.premier <<','<<umap2.Taille() << ' ';
unordered_map<const carboniser*, const carboniser*>umap1= {{'banane', 'jaune'},
{'raisin', 'vert'}, {'figure', 'violet'}, {'fraise', 'rapporter'}};
unordered_map<const carboniser*, const carboniser*>umap2= {{'cerise', 'rapporter'}, {'chaux', 'vert'}};
umap1.échanger(umap2);
unordered_map<const carboniser*, const carboniser*> ::itérateuriter1=umap1.commencer();
paire<const carboniser*, const carboniser*>pr1= *iter1;
unordered_map<const carboniser*, const carboniser*> ::itérateuriter2=umap2.commencer();
paire<const carboniser*, const carboniser*>pr2= *iter2;
cout<< 'Première clé et taille de umap1 : '<<pr1.premier <<','<<umap1.Taille() << ' ';
cout<< 'Première clé et taille de umap2'<<pr2.premier <<','<<umap2.Taille() << ' ';
La sortie est :
Première clé et taille de umap1 : lime, 2
Première clé et taille de fraise umap2, 4
La carte n'est pas ordonnée. Notez que la longueur d'une carte est augmentée si nécessaire. Les types de données doivent être les mêmes.
Classe et ses objets instanciés
Une valeur est à un type de données, comme un objet instancié est à une classe. La construction de carte non ordonnée peut également accepter une classe comme type de données. Le programme suivant illustre cela :
#comprendre#comprendre
en utilisant l'espace de noms std;
classe TheCla
{
Publique:
entiersur une;
statique carboniserch;
annulerfonction(carbonisernon, const carboniser *p)
{
cout<< 'Il y a ' <<sur une<< 'les livres valent' <<non<<p<< ' dans le magasin.' << ' ';
}
statique annuleramusant(carboniserch)
{
si (ch== 'à')
cout<< 'Fonction membre statique officielle' << ' ';
}
};
entierprincipale()
{
La Cla obj1;La Cla obj2;La Cla obj3;La Cla obj4;La Cla obj5;
unordered_map<const carboniser*,La Cla>umap;
umap= {{'banane',obj1}, {'raisin',obj2}, {'figure',obj3}, {'fraise',obj4}, {'chaux',obj5}};
cout<<umap.Taille() << ' ';
revenir 0;
}
La sortie est : 5.
La définition de classe a deux membres publics de données et deux fonctions membres publiques. Dans la fonction main(), différents objets de la classe sont instanciés. Une carte non ordonnée est ensuite instanciée, où chaque paire se compose du nom d'un fruit et d'un objet de la classe. La taille de la carte s'affiche. Le programme compile sans avertissement ni message d'erreur.
Application de la carte
Le tableau associe un index à value. Les paires clé/valeur existent dans de nombreuses situations de la vie, qui peuvent être programmées. La paire clé/valeur fruit/couleur n'est qu'un exemple. Un autre exemple est le nom des personnes et leur âge. Dans ce cas, la paire sera d'un type, paire. Il peut également être en couple. Dans ce dernier cas, la directive de prétraitement sera employée. Une paire clé/valeur peut toujours être les noms de couples mariés. Dans les pays où règne la polygamie, il y aura différentes épouses pour un même homme.
Formation d'une carte
Une carte n'est pas un tableau à deux dimensions, avec deux colonnes. Une carte fonctionne avec une fonction de hachage. La clé est codée par la fonction de hachage, en un entier d'un tableau. C'est ce tableau qui contient les valeurs. Donc, il y a en fait un tableau avec les valeurs, et les clés sont mappées sur les indices du tableau, et donc les correspondances entre les clés et les valeurs sont faites. Le hachage est un sujet vaste et n'est pas traité dans cet article.
Conclusion
Une carte, également appelée tableau associatif, est une liste d'éléments, où chaque élément est une paire clé/valeur. Ainsi, chaque clé correspond à une valeur. En C++, la carte est implémentée comme une structure de données avec des fonctions membres et des opérateurs. Une carte ordonnée est une carte où les paires d'éléments ont été ordonnées par clés. Une carte non ordonnée est une carte où il n'y a pas d'ordre.
Techniquement, un hachage se compose d'éléments de paire. En fait, la paire est une structure de données entière avec ses fonctions membres et ses opérateurs. Les deux paramètres de modèle pour la paire sont les deux mêmes paramètres de modèle pour unordered_map.
La liste initializer_list de la carte est un littéral de tableau de littéraux. Chaque littéral interne se compose de deux objets, la paire clé/valeur.
Les fonctions membres et les opérateurs pour unordered_map peuvent être classés sous les titres suivants : unordered_map construction/copy construction, unordered_map Capacity, unordered_map iterator, unordered_map Operations et unordered_map Modificateurs.
Un mappage non ordonné est utilisé lorsqu'une clé doit être mappée sur une valeur.
Chrys