Comprendre Unordered_Map::Find()
La fonction unordered_map::find() est conçue pour localiser un élément associé à une clé spécifiée dans un « unordered_map ». Sa déclaration varie selon que l'objet est qualifié de constante ou non, offrant ainsi une flexibilité dans son utilisation.
itérateur trouver ( const type de clé & k ) ;Ceci est utilisé lorsque le « unordered_map » n'est pas qualifié de constante. Ce code renvoie un itérateur qui pointe vers l'élément trouvé.
const_iterator trouver ( const type de clé & k ) const ;
Cette version est applicable lorsque le « unordered_map » est qualifié de constante. Il renvoie un itérateur constant avec un comportement similaire à la version non constante.
Paramètres:
Il prend un seul paramètre, « k », qui est la clé à rechercher dans le « unordered_map ».
Valeur de retour :
La valeur de retour dépend de la qualification de l'objet « unordered_map ».
La méthode renvoie un itérateur non constant si l'objet n'est pas constamment qualifié.
Si l'objet est qualifié de constante, la méthode renvoie un itérateur constant.
Complexité temporelle :
La complexité temporelle de std::unordered_map::find() est cruciale pour comprendre son efficacité :
Dans le cas moyen, la complexité temporelle est constante (O(1)), ce qui la rend très efficace pour les cas d'utilisation typiques.
Dans le pire des cas, la complexité temporelle devient linéaire (O(n)). Cependant, ce scénario est rare dans la pratique.
Exemple 1:
Explorons un exemple pratique pour illustrer l'utilisation et les avantages de unordered_map::find(). Dans cet exemple, une « unordered_map » est créée avec les caractères comme clés et les entiers correspondants comme valeurs. La fonction find() localise l'élément lié à la clé « p ». L'itérateur « ittr » est lié à l'élément trouvé et ses données sont imprimées sur la console. Voir le code suivant :
#include#include
en utilisant l'espace de noms std ;
int principal ( vide ) {
carte_non ordonnée < carboniser , int > décompresser = {
{ 'Dans' , 9 } ,
{ 'un' , 6 } ,
{ 'p' , 8 } ,
{ 'je' , 3 } ,
{ 's' , 4 } } ;
auto ittr = décomp. trouver ( 'p' ) ;
cout << 'Itérateur' ' << ittr->premier << ' ' pointe vers = ' << ittr -> deuxième << fin ;
retour 0 ; }
Décomposons le code pour en avoir une meilleure compréhension :
#include#include
Les fichiers d'en-tête nécessaires sont inclus :
L'espace de noms « std » simplifie le code. Il vous permet d'utiliser les éléments de la bibliothèque standard C++ sans les préfixer de « std :: ».
carte_non ordonnée < carboniser , int > décompresser = { { 'Dans' , 9 } , { 'un' , 6 } , { 'p' , 8 } , { 'je' , 3 } , { 's' , 4 } } ;Une 'unordered_map' nommée 'um' est créée avec les caractères ('w', 'a', 'p', 'm', 's') comme clés et les entiers correspondants (9, 6, 8, 3, 4 ) comme valeurs.
auto ittr = décomp. trouver ( 'p' ) ;La fonction find() est utilisée pour rechercher l'élément avec la clé « p » dans le « unordered_map » qui est « unomp ». L'itérateur « ittr » pointe vers l'élément identifié.
cout << 'Itérateur' ' << ittr->premier << ' ' pointe vers = ' << ittr -> deuxième << fin ;Le contenu pointé par l'itérateur est imprimé sur la console. Il imprime la clé (« p ») et la valeur associée (8) dans ce cas.
retour 0 ;Le programme se termine et renvoie 0 pour indiquer une exécution réussie.
Le résultat du code est donné ci-dessous pour votre référence :
Ce code est un exemple simple d'utilisation de unordered_map::find() pour rechercher et accéder efficacement aux éléments d'un « unordered_map ». L'itérateur fournit un moyen pratique d'accéder à la fois à la clé et à la valeur associée de l'élément trouvé.
Exemple 2 :
Voici un autre exemple simple de la fonction unordered_map::find(). Ce code démontre l'utilisation de « unordered_map » pour stocker les valeurs booléennes associées aux clés entières, puis utilise la fonction find() pour vérifier l'existence de clés spécifiques. Voyons le code suivant et comprenons ensuite comment il fonctionne :
#includeen utilisant l'espace de noms std ;
int principal ( ) {
carte_non ordonnée < int , bouffon > décompresser ;
décompresser [ 2 ] = vrai ;
décompresser [ 67 ] = FAUX ;
décompresser [ Quatre cinq ] = vrai ;
décompresser [ 98 ] = FAUX ;
si ( décomp. trouver ( 67 ) == décomp. fin ( ) )
cout << 'Élément introuvable' << fin ;
autre
cout << 'Élément trouvé' << fin ;
si ( décomp. trouver ( 42 ) == décomp. fin ( ) )
cout << 'Élément introuvable' << fin ;
autre
cout << 'Élément trouvé' << fin ;
retour 0 ;
}
Voici une description détaillée du code :
#includeCette ligne comprend un fichier d'en-tête qui couvre la plupart des bibliothèques C++ standard souvent utilisées dans la programmation compétitive. Cependant, dans un développement C++ classique, il est recommandé d’inclure les en-têtes spécifiques.
carte_non ordonnée < int , bouffon > décompresser ;Une « unordered_map » nommée « unomp » est créée avec des clés entières et des valeurs booléennes.
décompresser [ 2 ] = vrai ;décompresser [ 67 ] = FAUX ;
décompresser [ Quatre cinq ] = vrai ;
décompresser [ 98 ] = FAUX ;
Les paires clé-valeur sont insérées dans le « unordered_map ». Chaque clé (entier) est associée à une valeur booléenne.
si ( décomp. trouver ( 67 ) == décomp. fin ( ) )cout << 'Élément introuvable' << fin ;
autre
cout << 'Élément trouvé' << fin ;
La fonction find() est utilisée dans la condition if-else pour rechercher des clés spécifiques (67 et 42) dans la « unordered_map ». Si la clé est trouvée, « Élément trouvé » est imprimé. Sinon, « Élément non trouvé » est imprimé. Consultez le résultat suivant :
Ce code présente l'utilisation de base de « unordered_map » et de la fonction find() pour déterminer la présence ou l'absence de clés spécifiques dans la carte.
Exemple 3 :
Explorons un autre exemple qui démontre la recherche d'une valeur en fournissant une entrée au moment de l'exécution. Ce programme simple utilise une « unordered_map » pour stocker les noms (sous forme de clés) et les valeurs numériques associées (dans ce cas, représentant certains attributs). Il invite ensuite l'utilisateur à saisir un nom, à rechercher ce nom sur la carte à l'aide de la fonction find() et à imprimer la valeur associée si le nom est trouvé. Le code est donné ci-dessous pour votre référence :
#include#include
#include
en utilisant l'espace de noms std ;
int principal ( ) {
norme :: carte_non ordonnée < norme :: chaîne , double > décompresser = {
{ 'Héry' , 23 } ,
{ 'Autres' , 7.4 } ,
{ 'Kalsoom' , 1.2 } } ;
chaîne qui ;
cout << 'Qui cherches-tu? ' ;
obtenir la ligne ( manger , OMS ) ;
carte_non ordonnée < chaîne , double >:: const_iterator trouver = décomp. trouver ( OMS ) ;
si ( trouver == décomp. fin ( ) )
cout << 'pas trouvé' ;
autre
cout << fin << trouver -> d'abord << ' est ' << trouver -> deuxième << fin ;
retour 0 ;
}
Voici la répartition du code pour votre compréhension :
carte_non ordonnée < chaîne , double > décompresser = { } ;Une « unordered_map » nommée « unomp » est créée avec des clés de chaîne (noms) et des valeurs doubles.
chaîne qui ;L'utilisateur est invité à saisir un nom à l'écran et l'entrée est stockée dans la variable de chaîne « who ».
carte_non ordonnée < chaîne , double >:: const_iterator trouver = décomp. trouver ( OMS ) ;La fonction find() est utilisée pour rechercher le nom saisi dans le « unordered_map ». Le résultat est stocké dans l'itérateur « fnd ».
si ( trouver == décomp. fin ( ) )cout << 'pas trouvé' ;
autre
cout << fin << trouver -> d'abord << ' est ' << trouver -> deuxième << fin ;
Si l'itérateur « fnd » atteint la fin de « unordered_map » (end()), cela signifie que le nom n'a pas été trouvé et « not found » est imprimé. Sinon, le nom et sa valeur associée sont imprimés. Voici le résultat du code :
Ce code agit essentiellement comme un simple outil de recherche de nom utilisant une « unordered_map ». Il prend la saisie de l'utilisateur, recherche le nom sur la carte et fournit la valeur associée si le nom est trouvé.
Conclusion
La fonction unordered_map::find() en C++ fournit un mécanisme puissant pour localiser efficacement les éléments dans les conteneurs « unordered_map ». Sa complexité temporelle moyenne constante en fait un choix privilégié pour les opérations de recherche dans les scénarios où les paires clé-valeur doivent être accessibles rapidement. Les exemples fournis présentent son utilisation pratique, soulignant sa simplicité et son efficacité. En conclusion, la maîtrise de la fonction unordered_map::find() améliore la capacité d'un programmeur C++ à exploiter tout le potentiel des conteneurs « unordered_map », contribuant ainsi à la création d'applications optimisées et performantes.