Comment utiliser la carte C ++ non ordonnée

Une carte, également connue sous le nom de tableau associatif, est une liste d'éléments, où chaque élément est une paire clé / valeur. Donc, chaque clé correspond à une valeur. Différentes clés peuvent avoir la même valeur, pour un travail ordinaire. Par exemple, les touches peuvent être une liste de fruits et des valeurs correspondantes, les couleurs des fruits. En C ++, la carte est implémentée en tant que structure de données avec les fonctions des membres et les opérateurs. Une carte commandée est celle où les paires d'éléments ont été commandées par les clés. Une carte non ordonnée est celle où il n'y a pas d'ordre. Cet article explique comment utiliser la carte C ++ non ordonnée, écrite comme non ordonné_map. Vous avez besoin de connaissances dans les pointeurs C ++ pour comprendre cet article. Unecorded_map fait partie de la bibliothèque standard C ++.

Classe et objets

Une classe est un ensemble de variables et de fonctions qui fonctionnent ensemble, où les variables n'ont pas de valeurs attribuées à. Lorsque des valeurs sont affectées aux variables, la classe devient un objet. Différentes valeurs données à la même classe entraînent différents objets; c'est-à-dire que différents objets sont la même classe avec des valeurs différentes. La création d'un objet à partir d'une classe est censée instanier l'objet.

Le nom, non ordonné_map, est une classe. Un objet créé à partir de la classe non ordonnée_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 donnés, par le programmeur.

La création d'un objet à partir de la classe signifie la construction de l'objet; Cela signifie également instanciation.

Un programme C ++ qui utilise la classe non ordonnée_map, commence par les lignes suivantes en haut du fichier:

#inclure
#inclure
Utilisation de Namespace Std;

La première ligne est pour l'entrée / sortie. La deuxième ligne est de permettre au programme d'utiliser toutes les fonctionnalités de la classe non ordonnée_map. La troisième ligne permet au programme d'utiliser les noms dans l'espace de noms standard.

Surchargez une fonction

Lorsque deux ou plusieurs signatures de fonction ont le même nom, ce nom est considéré comme surchargé. Lorsqu'une fonction est appelée, le nombre et le type d'arguments, déterminez quelle fonction est réellement exécutée.

Construction de construction / copie

Construction simple

Une carte non ordonnée peut être construite et attribuée de valeurs comme suit:

non ordonné_map UMAP;
umap ["banane"] = "jaune";
umap ["raisin"] = "vert";
UMAP ["Fig"] = "Purple";

La déclaration commence par la spécialisation du modèle avec les types pour les paires de clés et de valeur. Ceci est suivi du nom choisi du 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:

non ordonné_map UMAP ("banane", "jaune",
"Grape", "Green", "Fig", "Purple");

Construction en attribuant Initializer_list
Exemple:

non ordonné_map UMAP = "banane", "jaune",
"Grape", "Green", "Fig", "Purple";

Construction en copie un autre non ordonné_map
Exemple:

non ordonné_map UMAP1 ("banane", "jaune",
"Grape", "Green", "Fig", "Purple");
non ordonné_map UMAP2 (UMAP1);

L'élément de paire

Le code suivant montre comment créer et accéder à l'élément paire:

paire pr = 'd', "mer";
couter << pr.first << '\n';
couter << pr.second << '\n';

La sortie est:

d
mer

les premiers et les seconds 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 les premier et deuxième.

Une paire est appelée, Value_Type dans le sujet de la carte non ordonnée.

Accès à l'élément non ordonné

mapped_type & opérateur [] (key_type && k)
Renvoie la valeur de la clé correspondante. Exemple:

non ordonné_map UMAP;
umap ["banane"] = "jaune";
umap ["raisin"] = "vert";
UMAP ["Fig"] = "Purple";
const char * ret = umap ["raisin"];
couter << ret <<'\n';

La sortie est: «vert». Les valeurs peuvent être attribuées de la même manière - voir ci-dessus.

Capacité non ordonnée_map

size_type size () const Noexcept
Renvoie le nombre de paires dans la carte.

non ordonné_map UMAP;
umap ["banane"] = "jaune";
umap ["raisin"] = "vert";
UMAP ["Fig"] = "Purple";
couter << umap.size() <<'\n';

La sortie est 3.

bool vide () const noexcept

Renvoie 1 pour true si la carte n'a pas de paire, et 0 pour false si elle a des paires. Exemple:

non ordonné_map UMAP;
couter << umap.empty() <<'\n';

La sortie est 1.

Retour des itérateurs et la classe non ordonnée

Un itérateur est comme un pointeur mais a plus de fonctionnalité que le pointeur.

begin () noexcept

Renvoie un itérateur qui pointe vers la première paire de l'objet MAP, comme dans le segment de code suivant:

non ordonné_map UMAP;
umap ["banane"] = "jaune"; umap ["raisin"] = "vert"; UMAP ["Fig"] = "Purple";
non ordonné_map:: iterator iter = umap.commencer();
paire pr = * iter;
couter << pr.first << ", " << pr.second << '\n';

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 MAP. Lorsque la construction d'objets est précédée par 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.

const non ordonné_map UMAP ("banane", "jaune",
"Grape", "Green", "Fig", "Purple");
non ordonné_map:: const_iterator iter = umap.commencer();
paire pr = * iter;
couter << pr.first << ", " << pr.second << '\n';

La sortie est: Fig, violet. La carte n'est pas ordonnée. Notez que Const_iterator a été utilisé cette fois, au lieu d'Iterator, pour recevoir l'itérateur retourné.

end () noexcept

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 d'objets de carte est précédée par const, l'expression «end () const» est exécutée au lieu de «end ()».

opérations non ordonnées_map

Iterator 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. Si cela 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:

non ordonné_map UMAP;
umap ['a'] = 'b'; UMAP ['C'] = 'D'; umap ['e'] = 'f';
non ordonné_map:: iterator iter = umap.trouver ('c');
if (umap.trouver ('c') != UMAP.fin())
paire pr = * iter;
couter << pr.first << ", " << pr.second << '\n';

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, faisant tous les éléments de la carte en lecture seule.

Modificateurs non ordonnés_map

paire insert (value_type && obj)
Une carte non ordonnée signifie que les paires ne sont en aucun ordre. Ainsi, le programme insère la paire à n'importe quel endroit où il trouve pratique. La fonction renvoie, paire. Si l'insertion a réussi, Bool sera 1 pour vrai, sinon ce serait 0 pour False. Si l'insertion est réussie, alors l'itérateur pointera vers l'élément nouvellement inséré. Le code suivant illustre l'utilisation:

non ordonné_map UMAP;
umap ["banane"] = "jaune";
umap ["raisin"] = "vert";
UMAP ["Fig"] = "Purple";
usine.insert ("Cherry", "Red", "Strawberry", "Red");
couter << umap.size() << '\n';

La sortie est: 5. Plus d'une paire peut être insérée.

size_type efface (const key_type & k)

Cette fonction efface une paire à partir du non ordonné_map. Le segment de code suivant illustre:

non ordonné_map UMAP;
umap ["banane"] = "jaune";
umap ["raisin"] = "vert";
UMAP ["Fig"] = "Purple";
int num = umap.Effacer ("raisin");
couter << umap.size() << '\n';

La sortie est 2.
Void Swap (non ordonné_map &)
Deux cartes non ordonnées peuvent être échangées, comme illustré dans ce segment de code:

non ordonné_map UMAP1 = "banane", "jaune",
"Grape", "Green", "Fig", "Purple", "Strawberry", "Red";
non ordonné_map UMAP2 = "Cherry", "Red", "Lime", "Green";
UMAP1.échange (UMAP2);
non ordonné_map:: Iterator iter1 = UMAP1.commencer();
paire pr1 = * iter1;
non ordonné_map:: iterator iter2 = umap2.commencer();
paire pr2 = * iter2;
couter << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
couter << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';
non ordonné_map UMAP1 = "banane", "jaune",
"Grape", "Green", "Fig", "Purple", "Strawberry", "Red";
non ordonné_map UMAP2 = "Cherry", "Red", "Lime", "Green";
UMAP1.échange (UMAP2);
non ordonné_map:: Iterator iter1 = UMAP1.commencer();
paire pr1 = * iter1;
non ordonné_map:: iterator iter2 = umap2.commencer();
paire pr2 = * iter2;
couter << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
couter << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';

La sortie est:

Première clé et taille de UMAP1: citron vert, 2
Première clé et taille de la 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, car un objet instancié est pour une classe. La construction de cartes non ordonnée peut également accepter une classe comme type de données. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
classe thecla
public:
int num;
Char statique Ch;
void func (char cha, const char * str)
couter << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

STATIC VOID FUN (char ch)
if (ch == 'a')
couter << "Official static member function" << '\n';

;
int main()

Thecla obj1; Thecla obj2; Thecla obj3; Thecla obj4; Thecla obj5;
non ordonné_map UMAP;
UMAP = "Banana", obj1, "Grape", obj2, "Fig", obj3, "Strawberry", obj4, "lime", obj5;
couter << umap.size() << '\n';
retour 0;

La sortie est: 5.

La définition de la classe a deux données publiques et deux fonctions des membres publics. Dans la fonction principale (), différents objets pour la classe sont instanciés. Une carte non ordonnée est alors instanciée, où chaque paire se compose du nom d'un fruit et d'un objet de la classe. La taille de la carte est affichée. Le programme se compile sans avertissement ni message d'erreur.

Application de la carte

Le tableau associe un index de la valeur. Des paires de clés / de valeur existent dans de nombreuses situations de la vie, qui peuvent être programmées. La paire de fruits / couleur clé / valeur n'est qu'un exemple. Un autre exemple est le nom des gens et de leur âge. Dans ce cas, la paire sera de type, paire. Il peut aussi être paire. Dans ce dernier cas, la directive de prétraitement sera utilisée. Une paire clé / valeur peut toujours être les noms des couples mariés. Dans les pays où il y a de la polygamie, il y aura différentes femmes pour un homme.

Formation d'une carte

Une carte n'est pas un tableau bidimensionnel, 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. Ainsi, il y a en fait un tableau avec les valeurs, et les clés sont mappées aux indices du tableau, et donc les correspondances entre les clés et les valeurs sont faites. Le hachage est un sujet étendu et n'est pas couvert dans cet article.

Conclusion

Une carte, également connue sous le nom de tableau associatif, est une liste d'éléments, où chaque élément est une paire clé / valeur. Donc, chaque clé correspond à une valeur. En C ++, la carte est implémentée en tant que structure de données avec les fonctions des membres et les opérateurs. Une carte commandée est celle où les paires d'éléments ont été commandées par les clés. Une carte non ordonnée est celle où il n'y a pas de commande.

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 et opérateurs membres. Les deux paramètres de modèle pour la paire sont les deux mêmes paramètres de modèle pour le non ordonné_map.

L'initialisateur_liste de la carte est un littéral de littéraux. Chaque littéral interne se compose de deux objets, la paire clé / valeur.

Les fonctions et les opérateurs des membres pour UNCORD_MAP peuvent être classés sous les titres suivants: Construction / Copie de construction non ordonnée, Capacité non ordonnée_map, opérations non ordonnées_map, opérations non ordonnées_map et modificateurs non ordonnés_map.

Une carte non ordonnée est utilisée lorsqu'une clé doit être mappée à une valeur.