Phenquestions
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. La création d'un objet à partir d'une classe est dite instancier 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 donnés, par le programmeur.
Créer un objet à partir de la classe signifie construire l'objet ; cela signifie aussi instancier.
Un programme C++ qui utilise la classe unordered_map commence par les lignes suivantes en haut du fichier :
#inclure#inclure
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 ou plusieurs signatures de fonction différentes 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_mapumap["banane"] = "jaune";
umap["raisin"] = "vert";
umap["fig"] = "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", "figue", "violet");
Construction en affectant Initializer_list
Exemple:
"raisin", "vert", "figue", "violet" ;
Construction en copiant un autre unordered_map
Exemple:
"raisin", "vert", "figue", "violet");
unordered_map
La paire Élément
Le code suivant montre comment créer et accéder à l'élément pair :
pairecout << pr.first << '\n';
cout << pr.second << '\n';
La sortie est :
rémer
le premier et le 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 le premier et le deuxième.
Une paire est appelée, value_type dans le sujet de la carte non ordonnée.
unordered_map Accès aux éléments
opérateur mapped_type&[](key_type&& k)
Renvoie la valeur de la clé correspondante. Exemple:
umap["banane"] = "jaune";
umap["raisin"] = "vert";
umap["fig"] = "violet";
const char *ret = umap["raisin"];
cout << ret <<'\n';
La sortie est : « vert ». 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["fig"] = "violet";
cout << umap.size() <<'\n';
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_mapcout << umap.empty() <<'\n';
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_mapumap["banane"] = "jaune"; umap["raisin"] = "vert"; umap["fig"] = "violet";
unordered_map
paire
cout << pr.first << ", " << pr.second << '\n';
La sortie est : figue, 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 à la place 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 unordered_map"raisin", "vert", "figue", "violet");
unordered_map
paire
cout << pr.first << ", " << pr.second << '\n';
La sortie est : figue, 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 carte 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_mapumap['a'] = 'b'; umap['c'] = 'd'; umap['e'] = 'f';
unordered_map
si (umap.trouver('c') != umap.finir())
paire
cout << 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, rendant tous les éléments de la carte en lecture seule.
unordered_map Modificateurs
paire
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 retourne, paire
umap["banane"] = "jaune";
umap["raisin"] = "vert";
umap["fig"] = "violet";
umap.insert("cerise", "rouge", "fraise", "rouge");
cout << umap.size() << '\n';
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_mapumap["banane"] = "jaune";
umap["raisin"] = "vert";
umap["fig"] = "violet";
int num = umap.effacer("raisin");
cout << umap.size() << '\n';
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", "figue", "violet", "fraise", "rouge" ;
unordered_map
umap1.échange(umap2) ;
unordered_map
paire
unordered_map
paire
cout << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
cout << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';
unordered_map
"raisin", "vert", "figue", "violet", "fraise", "rouge" ;
unordered_map
umap1.échange(umap2) ;
unordered_map
paire
unordered_map
paire
cout << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
cout << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';
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 :
#inclure#inclure
en utilisant l'espace de noms std ;
classe TheCla
Publique:
nombre entier ;
char ch statique;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
amusement du vide statique (char ch)
si (ch == 'a')
cout << "Official static member function" << '\n';
;
int main()
LeCla obj1; TheCla obj2; TheCla obj3; TheCla obj4; LeCla obj5;
unordered_map
umap = "banane", obj1, "raisin", obj2, "figue", obj3, "fraise", obj4, "citron vert", obj5 ;
cout << umap.size() << '\n';
renvoie 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 indice à la valeur. 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
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 couvert 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 consiste en une paire
Le initializer_list pour 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.
Une carte non ordonnée est utilisée lorsqu'une clé doit être mappée sur une valeur.
Chrys
