La bibliothèque C++ STL nous fournit une classe map. Les cartes sont considérées comme des conteneurs associatifs qui conservent des objets dans une paire de valeurs de clé ordonnées et de valeurs mappées. Il ne peut jamais y avoir deux valeurs mappées avec la même valeur de clé. La classe Map fournit de nombreuses fonctions, mais nous discuterons ici de la map.at() fonction. L'élément mappé à la valeur de la clé est transmis en tant que paramètre de la fonction qui est référencé à l'aide de la map.at() fonction. Lorsque nous essayons d'accéder à un élément qui n'est pas à l'intérieur de la plage du conteneur, le map.at() La fonction évalue la plage du conteneur et lève une exception.
Syntaxe de la fonction map.at()
Nous devons suivre la syntaxe ci-dessous pour implémenter la fonction map.at() en C++.
Map_variable.at ( clé / paire de valeurs )
Nous avons utilisé l'objet map nommé 'Map_variable' avec la à() fonction. Il renvoie l'élément qui est directement référencé et pointe vers la valeur de clé spécifiée. La carte de clés de données dépend principalement de la portée de la carte. Si ce n'est pas le cas, il est possible qu'une exception ou une erreur soit renvoyée au moment de l'exécution, ce qui signifie que la valeur est au-delà de la plage définie. Maintenant, nous allons utiliser cette syntaxe dans les codes C++ pour montrer que cela fonctionne.
Exemple 1 : Utilisation de la fonction map.at()
Le programme est implémenté pour démontrer la fonction map.at. Nous avons lié le à() fonction avec le carte() fonction qui prend des valeurs d'entrée et montre sa fonctionnalité. Pour cela, nous avons rempli la section d'en-tête du programme en important le module map avec un autre module requis pour c++. Ensuite, nous avons appelé le principale() fonction pour la déclaration map de la classe map. L'objet de la carte est étiqueté comme 'MyMap'. Nous créons la liste des cartes en donnant la clé et la valeur de la carte.
Après cela, nous avons invoqué le map.at() fonction qui mappe la chaîne spécifiée à un entier. Ensuite, nous avons imprimé les résultats de la map.at() fonction de la boucle for. La boucle for utilise la référence de mot-clé « auto ». Le mot-clé auto indique que l'initialiseur supprimera automatiquement le type de la variable de celui qui est déclaré. L'instruction cout imprimera les paires dans l'ordre renvoyé par le map.at() fonction.
#include#include
#include
int main ( )
std : :map < std :: chaîne, int > MaCarte = {
{ 'Pomme', 0 } ,
{ 'les raisins' , 0 } ,
{ 'mangues' , 0 } }
MyMap.at ( 'Pomme' ) = 5 ;
MyMap.at ( 'les raisins' ) = dix ;
MyMap.at ( 'mangues' ) = 6 ;
pour ( auto & m : Ma carte ) {
std :: cout << m.premier << ' : ' << m.seconde << '\n' ; }
< fort > revenir 0 ;
}
Maintenant, nous avons les résultats du programme ci-dessus qui implémente le map.at() fonction. Tous les nombres entiers spécifiés qui sont dans la plage sont affichés contre chaque chaîne.
Exemple 2 : Utilisation de la fonction map.at() pour l'exception out_of_range
Nous avons discuté à travers un exemple de programme de l'utilisation du carte.at fonction en C++. Maintenant, nous avons implémenté un autre carte.at dans le programme. Mais cette fois, il renverra la valeur présentée à l'intérieur de la carte ainsi que l'exception out_of_range lorsque la clé n'est pas spécifiée. Comme nous devons utiliser le carte.at fonction, nous avons donc ajouté le module de carte dans l'en-tête. Ensuite, nous avons défini la fonction main où le « void » est passé en paramètre.
À l'intérieur de la fonction principale, nous avons initialisé le constructeur de liste en créant l'objet map en tant que 'm1'. La liste de cartes a différentes chaînes de clés et les valeurs entières qui leur sont associées. Ensuite, nous avons imprimé la clé 'i' en la faisant passer par le carte.at fonction. Nous avons utilisé le bloc try-catch. Dans le bloc try, nous avons présenté la clé de non-existence dans le carte.at fonction. Comme la clé est hors de la plage, le bloc try génère l'erreur.
#include#include
en utilisant l'espace de noms std ;
int main ( annuler ) {
carte < char, int > m1 = {
{ 'l' , 1 } ,
{ 'je' , deux } ,
{ 'n' , 3 } ,
{ 'dans' , 4 } ,
{ 'X' , 5 } ,
} ;
cout << 'map key value m1['i'] = ' << m1.at ( 'je' ) << fin ;
essayer {
m1.at ( 'O' ) ;
} attraper ( const out_of_range & et ) {
cerr << 'Erreur à' << e. quoi ( ) << fin ;
}
revenir 0 ;
}
Nous pouvons visualiser à partir de la capture d'écran de sortie que le map.at() La fonction renvoie uniquement les clés présentes dans la carte. Les clés hors plage génèrent l'erreur car l'erreur s'affiche lorsque nous passons la clé 'y' dans le carte.at fonction.
Exemple 3 : Utilisation de la fonction map.at() pour accéder aux éléments
Un élément est accessible à l'aide de l'élément de chiffres spécifié à partir de la fonction map.at. Implémentons ce programme pour accomplir la déclaration ci-dessus. Nous avons d'abord défini le module de carte dans la section d'en-tête car il est nécessaire pour accéder au carte.at fonction. Ensuite, nous avons la fonction principale où la classe de carte a initialisé l'objet de carte en tant que 'Carte'. Avec cet objet « Map », nous avons généré les clés des chaînes et leur avons attribué la valeur du chiffre. Après cela, nous avons appelé le carte.at une fonction avec l'instruction cout et passé la clé 'Exemple' comme entrée.
#include#include
#include
en utilisant l'espace de noms std ;
int main ( )
{
carte < chaîne, entier > Carte;
Carte [ 'Mon' ] = 1 ;
Carte [ 'c++' ] = deux ;
Carte [ 'Carte' ] = 3 ;
Carte [ 'Exemple' ] = 4 ;
écoute << Carte.at ( 'Exemple' ) ;
revenir 0 ;
}
L'élément digit est renvoyé par rapport à la clé spécifiée dans le carte.at fonction. Le résultat donne la valeur « 4 » car ce chiffre est attribué à l'élément clé « Exemple » d'une carte.
Exemple 4 : Utilisation de la fonction map.at() pour modifier des éléments
Considérons un exemple simple de modification de la valeur associée à la valeur clé. Nous avons créé la liste de la carte en appelant la classe map et en créant l'objet « M1 ». Nous avons attribué la valeur de chaîne à chaque clé de la carte. Ensuite, nous devons utiliser les carte.at fonction. Dans le carte.at fonction, nous avons utilisé les clés spécifiées et attribué les nouvelles valeurs de chaîne à ces clés. Maintenant, ces valeurs seront modifiées avec la précédente. À l'aide de la boucle for, nous avons itéré chaque élément de la carte et l'avons affiché en sortie.
#include#include
#include
en utilisant l'espace de noms std ;
int main ( )
{
carte < entier, chaîne > M1 = {
{ dix , 'c++' } ,
{ vingt , 'Java' } ,
{ 30 , 'python' } ,
{ 40 , 'csharp' } ,
{ cinquante , 'OUVERT' } } ;
M1.at ( vingt ) = 'Tensorflow' ;
M1.at ( 30 ) = 'Linux' ;
M1.at ( cinquante ) = 'Scala' ;
écoute << ' \n Éléments:' << fin ;
pour ( auto & x : M1 ) {
écoute << x.premier << ' : ' << x.seconde << '\n' ;
}
revenir 0 ;
}
Notez que les valeurs obtenues en sortie ont modifié les valeurs de chaîne nouvellement attribuées dans le carte.at fonction. Les valeurs mises à jour sont présentées dans l'instantané ci-dessous.
Conclusion
L'article concerne la fonction map.at. Nous avons fourni la fonctionnalité de la fonction map.at() via sa syntaxe et l'exemple est implémenté avec le compilateur C++. La fonction map.at() est très utile car elle permet l'accessibilité des éléments et renvoie une exception ou une erreur claire qui décrit la situation qui s'est produite lors de l'appel de la méthode. De plus, nous pouvons attribuer de nouvelles valeurs à la clé d'existence via la fonction map.at.