C++ STL-biblioteket ger oss en kartklass. Kartor anses vara associativa behållare som behåller objekt i ett par ordnade nyckelvärden och mappade värden. Det kan aldrig finnas två mappade värden med samma nyckelvärde. Kartklass ger många funktioner men här kommer vi att diskutera map.at() fungera. Det mappade elementet till nyckelvärdet skickas som funktionens parameter som refereras med hjälp av map.at() fungera. När vi försöker komma till ett element som inte är inom containerns räckvidd, visas map.at() funktionen utvärderar containerns räckvidd och skapar ett undantag.
Syntax för map.at() Funktion
Vi måste följa syntaxen nedan för att implementera map.at()-funktionen i C++.
Map_variable.at ( nyckel- / värdepar )
Vi har använt kartobjektet som heter 'Map_variable' med på() fungera. Det returnerar elementet som är direkt refererat och pekar på det angivna nyckelvärdet. Datanyckelkartan beror mest på kartans räckvidd. Om det inte är det, finns det en möjlighet att ett undantag eller fel kommer att returneras vid körningstidpunkten som betyder att värdet ligger utanför det definierade intervallet. Nu kommer vi att använda denna syntax i C++-koderna för att visa att det fungerar.
Exempel 1: Använda map.at()-funktionen
Programmet är implementerat för att demonstrera map.at-funktionen. Vi har länkat till på() funktion med Karta() funktion som tar några ingångsvärden och visar dess funktionalitet. För detta har vi fyllt programmets huvudsektion genom att importera kartmodulen med en annan obligatorisk modul för c++. Sedan har vi ringt till main() funktion för kartdeklarationen från kartklassen. Objektet på kartan är märkt som 'MyMap'. Vi skapar listan över kartor genom att ge kartnyckeln och värde.
Efter detta åberopade vi map.at() funktion som mappar den angivna strängen till ett heltal. Sedan skrev vi ut resultaten från map.at() funktion från for-slingan. For-loopen använder nyckelordsreferensen 'auto'. Nyckelordet auto indikerar att initialiseraren automatiskt tar bort variabelns typ från den som deklareras. Cout uttalandet kommer att skriva ut paren i den ordning som returneras från map.at() fungera.
#include#inkludera
#inkludera
int main ( )
std: :karta < std::string,int > Min karta = {
{ 'äpple', 0 } ,
{ 'druvor' , 0 } ,
{ 'mango' , 0 } }
MyMap.at ( 'äpple' ) = 5 ;
MyMap.at ( 'druvor' ) = 10 ;
MyMap.at ( 'mango' ) = 6 ;
för ( bil & m: Min karta ) {
std::cout << m.först << ': ' << m.sekund << '\n' ; }
< stark > lämna tillbaka 0 ;
}
Nu har vi resultaten från ovanstående program som implementerar map.at() fungera. Alla angivna heltal som är inom intervallet visas mot varje sträng.
Exempel 2: Använder map.at()-funktionen för undantag utanför_intervallet
Vi har genom ett exempelprogram diskuterat användningen av map.at funktion i C++. Nu har vi implementerat en till map.at i programmet. Men den här gången kommer den att returnera värdet som presenteras i kartan och även undantaget utanför_intervall när nyckeln inte är specificerad. Eftersom vi måste använda map.at funktion, så vi har lagt till kartmodulen i rubriken. Sedan har vi definierat huvudfunktionen där 'void' skickas som en parameter.
Inuti huvudfunktionen har vi initierat listkonstruktorn genom att skapa kartobjektet som 'm1'. Kartlistan har olika nyckelsträngar och heltalsvärden mot dem. Sedan skrev vi ut nyckeln 'i' genom att föra den genom map.at fungera. Vi har använt try-catch-blocket. I försöksblocket har vi presenterat icke-existensnyckeln i map.at fungera. Eftersom nyckeln är utanför intervallet kommer försöksblocket att kasta felet.
#include#inkludera
använder namnutrymme std;
int main ( tomhet ) {
Karta < char, int > m1 = {
{ 'l' , 1 } ,
{ 'jag' , två } ,
{ 'n' , 3 } ,
{ 'i' , 4 } ,
{ 'x' , 5 } ,
} ;
cout << 'mapnyckelvärde m1['i'] = ' << m1.at ( 'jag' ) << endl;
Prova {
m1.at ( 'Y' ) ;
} fånga ( const out_of_range & och ) {
cerr << 'Fel vid' << e.vad ( ) << endl;
}
lämna tillbaka 0 ;
}
Vi kan visualisera från utdataskärmdumpen att map.at() Funktionen returnerar endast de nycklar som finns på kartan. Nycklarna utanför räckvidd ger felet eftersom felet visas när vi skickade tangenten 'y' i map.at fungera.
Exempel 3: Använda map.at()-funktionen för att komma åt element
Ett element kan nås med det angivna elementet av siffror från map.at-funktionen. Låt oss implementera detta program för att uppnå ovanstående uttalande. Vi har definierat kartmodulen först i rubriken eftersom den krävs för att komma åt map.at fungera. Sedan har vi huvudfunktionen där kartklassen initierade kartobjektet som 'Map'. Med detta 'Map'-objekt har vi genererat nycklarna till strängar och tilldelat värdet på siffran till dem. Efter det ringde vi till map.at en funktion med cout-satsen och skickade 'Exempel'-tangenten som en ingång.
#include#inkludera
#inkludera
använder namnutrymme std;
int main ( )
{
Karta < sträng, int > Karta;
Karta [ 'Min' ] = 1 ;
Karta [ 'c++' ] = två ;
Karta [ 'Karta' ] = 3 ;
Karta [ 'Exempel' ] = 4 ;
cout << Map.at ( 'Exempel' ) ;
lämna tillbaka 0 ;
}
Sifferelementet returneras mot den angivna nyckeln i map.at fungera. Resultatet ger värdet '4' eftersom denna siffra är tilldelad nyckelelementet 'Exempel' på en karta.
Exempel 4: Använda map.at()-funktionen för att ändra element
Låt oss överväga ett enkelt exempel på att ändra värdet som är associerat med nyckelvärdet. Vi har skapat listan över kartan genom att kalla kartklassen och skapa objektet 'M1'. Vi har tilldelat strängvärdet mot varje tangent på kartan. Då måste vi använda map.at fungera. I den map.at funktion, har vi använt de angivna nycklarna och tilldelat de nya strängvärdena mot dessa nycklar. Nu kommer dessa värden att ändras med det föregående. Med hjälp av for loop har vi itererat varje element från kartan och visat det som en utdata.
#include#inkludera
#inkludera
använder namnutrymme std;
int main ( )
{
Karta < int, sträng > M1 = {
{ 10 , 'c++' } ,
{ tjugo , 'java' } ,
{ 30 , 'pytonorm' } ,
{ 40 , 'csharp' } ,
{ femtio , 'ÖPPNA' } } ;
M1.at ( tjugo ) = 'Tensorflöde' ;
M1.at ( 30 ) = 'Linux' ;
M1.at ( femtio ) = 'Scala' ;
cout << ' \n Element:' << endl;
för ( bil & x: M1 ) {
cout << x.först << ': ' << x.sekund << '\n' ;
}
lämna tillbaka 0 ;
}
Observera att värden som erhållits som utdata har modifierat de nyligen tilldelade strängvärdena i map.at fungera. De uppdaterade värdena visas i ögonblicksbilden nedan.
Slutsats
Artikeln handlar om funktionen map.at. Vi har tillhandahållit funktionaliteten för funktionen map.at() genom dess syntax och exemplet är implementerat med C++-kompilatorn. Map.at()-funktionen är mycket användbar eftersom den tillåter elementtillgänglighet och returnerar ett tydligt undantag eller fel som beskriver situationen som uppstod när metoden anropas. Dessutom kan vi tilldela nya värden mot existensnyckeln genom funktionen map.at.