De C++ STL-bibliotheek biedt ons een kaartklasse. Kaarten worden beschouwd als associatieve containers die objecten vasthouden in een paar geordende sleutelwaarden en toegewezen waarden. Er kunnen nooit twee toegewezen waarden met dezelfde sleutelwaarde zijn. De kaartklasse biedt veel functies, maar hier bespreken we de kaart.at() functie. Het toegewezen element aan de sleutelwaarde wordt doorgegeven als de parameter van de functie waarnaar wordt verwezen met de kaart.at() functie. Wanneer we proberen bij een element te komen dat niet binnen het bereik van de container ligt, wordt de kaart.at() functie evalueert het bereik van de container en genereert een uitzondering.
Syntaxis van map.at() Functie
We moeten de onderstaande syntaxis volgen om de functie map.at() in C++ te implementeren.
Map_variable.at ( sleutel / waardepaar )
We hebben het kaartobject met de naam 'Map_variable' gebruikt met de Bij() functie. Het retourneert het element waarnaar direct wordt verwezen en verwijst naar de opgegeven sleutelwaarde. De gegevenssleutelkaart hangt meestal af van het bereik van de kaart. Als dit niet het geval is, bestaat de mogelijkheid dat er tijdens de uitvoering een uitzondering of fout wordt geretourneerd die aangeeft dat de waarde buiten het gedefinieerde bereik ligt. Nu zullen we deze syntaxis in de C++-codes gebruiken om te laten zien dat het werkt.
Voorbeeld 1: De functie map.at() gebruiken
Het programma is geïmplementeerd om de functie map.at te demonstreren. We hebben de gekoppeld Bij() functie met de kaart() functie die enkele invoerwaarden nodig heeft en de functionaliteit ervan laat zien. Hiervoor hebben we de koptekstsectie van het programma gevuld door de kaartmodule te importeren met een andere vereiste module voor c++. Dan hebben we de genoemd hoofd() functie voor de kaartdeclaratie van de kaartklasse. Het object van de kaart wordt aangeduid als 'MyMap'. We maken de lijst met kaarten door de kaartsleutel en -waarde op te geven.
Hierna riepen we de kaart.at() functie die de opgegeven tekenreeks toewijst aan een geheel getal. Vervolgens hebben we de resultaten afgedrukt van de kaart.at() functie van de for-lus. De for-lus gebruikt de trefwoordreferentie 'auto'. Het auto-trefwoord geeft aan dat de initializer automatisch het type van de variabele verwijdert van het type dat wordt gedeclareerd. De cout-verklaring drukt de paren af in de volgorde die wordt geretourneerd door de kaart.at() functie.
#include#include
#include
int hoofd ( )
standaard: :kaart < std::string,int > MijnKaart = {
{ 'appel', 0 } ,
{ 'druiven' , 0 } ,
{ 'mango's' , 0 } }
MijnKaart.at ( 'appel' ) = 5 ;
MijnKaart.at ( 'druiven' ) = 10 ;
MijnKaart.at ( 'mango's' ) = 6 ;
voor ( auto & m: Mijn Kaart ) {
standaard::cout << m.eerst << ': ' << m.seconde << '\n' ; }
< krachtig > opbrengst 0 ;
}
Nu hebben we de resultaten van het bovenstaande programma dat de implementeert kaart.at() functie. Alle opgegeven gehele getallen die binnen het bereik vallen, worden weergegeven bij elke tekenreeks.
Voorbeeld 2: De functie map.at() gebruiken voor uitzondering buiten bereik
We hebben via een voorbeeldprogramma het gebruik van de map.at functie in C++. Nu hebben we een andere geïmplementeerd map.at op het programma. Maar deze keer retourneert het de waarde die in de kaart wordt weergegeven en ook de uitzondering buiten bereik wanneer de sleutel niet is opgegeven. Omdat we de moeten gebruiken map.at functie, dus hebben we de kaartmodule in de header toegevoegd. Vervolgens hebben we de hoofdfunctie gedefinieerd waarbij de 'leegte' als parameter wordt doorgegeven.
Binnen de hoofdfunctie hebben we de lijstconstructor geïnitialiseerd door het kaartobject als 'm1' te maken. De kaartlijst heeft verschillende reeksen sleutels en de gehele waarden daar tegenover. Vervolgens hebben we de sleutel 'i' afgedrukt door deze door de map.at functie. We hebben het try-catch-blok gebruikt. In het try-blok hebben we de niet-bestaanssleutel gepresenteerd in de map.at functie. Omdat de sleutel buiten het bereik is, zal het try-blok de fout veroorzaken.
#include#include
namespace std; gebruiken;
int hoofd ( leegte ) {
kaart < char, int > m1 = {
{ 'ik' , 1 } ,
{ 'i' , twee } ,
{ 'n' , 3 } ,
{ 'in' , 4 } ,
{ 'x' , 5 } ,
} ;
cout << 'kaart sleutelwaarde m1['i'] = ' << m1.at ( 'i' ) << endl;
proberen {
m1.at ( 'J' ) ;
} vangst ( const out_of_range & en ) {
zeker << 'Fout bij ' << e.wat? ( ) << endl;
}
opbrengst 0 ;
}
We kunnen uit de output-screenshot visualiseren dat de kaart.at() functie retourneert alleen de sleutels die aanwezig zijn in de kaart. De sleutels die buiten het bereik vallen, geven de fout omdat de fout wordt weergegeven wanneer we de sleutel 'y' in de . hebben doorgegeven map.at functie.
Voorbeeld 3: De functie map.at() gebruiken voor toegang tot elementen
Een element kan worden benaderd met behulp van het opgegeven cijferelement uit de map.at-functie. Laten we dit programma implementeren om de bovenstaande verklaring te volbrengen. We hebben de kaartmodule eerst gedefinieerd in het kopgedeelte omdat deze nodig is om toegang te krijgen tot de map.at functie. Dan hebben we de hoofdfunctie waarbij de kaartklasse het kaartobject als 'Kaart' heeft geïnitialiseerd. Met dit object 'Map' hebben we de sleutels van strings gegenereerd en de waarde van het cijfer eraan toegewezen. Daarna belden we de map.at een functie met de cout-instructie en gaf de toets 'Voorbeeld' als invoer door.
#include#include
#include
namespace std; gebruiken;
int hoofd ( )
{
kaart < string, int > Kaart;
Kaart [ 'Mijn' ] = 1 ;
Kaart [ 'c++' ] = twee ;
Kaart [ 'Kaart' ] = 3 ;
Kaart [ 'Voorbeeld' ] = 4 ;
cout << Kaart.at ( 'Voorbeeld' ) ;
opbrengst 0 ;
}
Het cijferelement wordt geretourneerd tegen de opgegeven sleutel in de map.at functie. Het resultaat geeft de waarde '4' omdat dit cijfer is toegewezen aan het sleutelelement 'Voorbeeld' van een kaart.
Voorbeeld 4: De functie map.at() gebruiken voor het wijzigen van elementen
Laten we eens kijken naar een eenvoudig voorbeeld van het wijzigen van de waarde die is gekoppeld aan de sleutelwaarde. We hebben de lijst van de kaart gemaakt door de kaartklasse aan te roepen en het object 'M1' te maken. We hebben de tekenreekswaarde toegewezen aan elke toets van de kaart. Dan moeten we gebruik maken van de map.at functie. In de map.at functie hebben we de opgegeven sleutels gebruikt en de nieuwe tekenreekswaarden toegewezen aan die sleutels. Nu worden deze waarden gewijzigd met de vorige. Met behulp van for loop hebben we elk element van de kaart herhaald en als uitvoer weergegeven.
#include#include
#include
namespace std; gebruiken;
int hoofd ( )
{
kaart < int,string > M1 = {
{ 10 , 'c++' } ,
{ twintig , 'Java' } ,
{ 30 , 'Python' } ,
{ 40 , 'scherp' } ,
{ vijftig , 'OPEN' } } ;
M1.at ( twintig ) = 'Tensorstroom' ;
M1.at ( 30 ) = 'Linux' ;
M1.at ( vijftig ) = 'Scala' ;
cout << ' \n Elementen:' << endl;
voor ( auto & x: M1 ) {
cout << x.eerst << ': ' << x.seconde << '\n' ;
}
opbrengst 0 ;
}
Merk op dat waarden die als uitvoer zijn verkregen de nieuw toegewezen tekenreekswaarden in de . hebben gewijzigd map.at functie. De bijgewerkte waarden worden weergegeven in de onderstaande momentopname.
Conclusie
Het artikel gaat over de functie map.at. We hebben de functionaliteit van de functie map.at() geleverd via de syntaxis en het voorbeeld is geïmplementeerd met de C++-compiler. De functie map.at() is zeer nuttig omdat het elementtoegankelijkheid mogelijk maakt en een duidelijke uitzondering of fout retourneert die de situatie beschrijft die zich voordeed toen de methode werd aangeroepen. Verder kunnen we nieuwe waarden toewijzen aan de existentiesleutel via de map.at-functie.