Ang C++ STL library ay nagbibigay sa amin ng klase ng mapa. Ang mga mapa ay itinuturing na nag-uugnay na mga lalagyan na nagpapanatili ng mga bagay sa isang pares ng nakaayos na mga pangunahing halaga at mga nakamapang halaga. Hindi kailanman maaaring magkaroon ng dalawang naka-map na value na may parehong key value. Ang klase ng mapa ay nagbibigay ng maraming function ngunit dito tatalakayin natin ang map.at() function. Ang naka-map na elemento sa key value ay ipinapasa bilang parameter ng function na nire-reference gamit ang map.at() function. Kapag sinubukan naming makarating sa isang elemento na wala sa saklaw ng container, ang map.at() sinusuri ng function ang saklaw ng container at naglalabas ng exception.
Syntax ng map.at() Function
Kailangan nating sundin ang syntax sa ibaba para ipatupad ang map.at() function sa C++.
Map_variable.at ( susi / pares ng halaga )
Ginamit namin ang object ng mapa na pinangalanang 'Map_variable' kasama ang sa() function. Ibinabalik nito ang elemento na direktang isinangguni at tumuturo sa tinukoy na halaga ng key. Ang data key map ay kadalasang nakadepende sa hanay ng mapa. Kung hindi, may posibilidad na ang isang exception o error ay ibabalik sa oras ng pagpapatupad na nagpapahiwatig na ang halaga ay lampas sa tinukoy na hanay. Ngayon, gagamitin namin ang syntax na ito sa mga C++ code para ipakita na gumagana ito.
Halimbawa 1: Paggamit ng map.at() Function
Ang programa ay ipinatupad upang ipakita ang mapa.at function. Na-link namin ang sa() function kasama ang mapa() function na kumukuha ng ilang value ng input at nagpapakita ng functionality nito. Para dito, pinunan namin ang seksyon ng header ng programa sa pamamagitan ng pag-import ng module ng mapa gamit ang isa pang kinakailangang module para sa c++. Pagkatapos, tinawagan namin ang pangunahing() function para sa deklarasyon ng mapa mula sa klase ng mapa. Ang object ng mapa ay may label na 'MyMap'. Lumilikha kami ng listahan ng mga mapa sa pamamagitan ng pagbibigay ng key at halaga ng mapa.
Pagkatapos nito, tinawag namin ang map.at() function na nagmamapa ng tinukoy na string sa isang integer. Pagkatapos, nag-print kami ng mga resulta mula sa map.at() function mula sa para sa loop. Ang for loop ay gumagamit ng 'auto' na sanggunian ng keyword. Isinasaad ng auto keyword na awtomatikong aalisin ng initializer ang uri ng variable mula sa idineklara. Ipi-print ng cout statement ang mga pares sa pagkakasunud-sunod na ibinalik mula sa map.at() function.
#include#include
#include
int pangunahing ( )
std: :mapa < std::string,int > MyMap = {
{ 'mansanas', 0 } ,
{ 'ubas' , 0 } ,
{ 'mangga' , 0 } }
MyMap.at ( 'mansanas' ) = 5 ;
MyMap.at ( 'ubas' ) = 10 ;
MyMap.at ( 'mangga' ) = 6 ;
para sa ( sasakyan at m: MyMap ) {
std::cout << m.una << ': ' << m.pangalawa << '\n' ; }
< malakas > bumalik 0 ;
}
Ngayon, mayroon kaming mga resulta mula sa programa sa itaas na nagpapatupad ng map.at() function. Ang lahat ng mga tinukoy na integer na nasa hanay ay ipinapakita laban sa bawat string.
Halimbawa 2: Paggamit ng map.at() Function para sa out_of_range Exception
Napag-usapan namin sa pamamagitan ng isang halimbawang programa ang paggamit ng mapa.at function sa C++. Ngayon, isa pa ang ipinatupad namin mapa.at sa programa. Ngunit sa pagkakataong ito, ibabalik nito ang value na ipinakita sa loob ng mapa at gayundin ang out_of_range exception kapag hindi tinukoy ang key. Habang kailangan nating gamitin ang mapa.at function, kaya idinagdag namin ang module ng mapa sa header. Pagkatapos, tinukoy namin ang pangunahing function kung saan ang 'walang bisa' ay ipinasa bilang isang parameter.
Sa loob ng pangunahing pag-andar, sinimulan namin ang tagabuo ng listahan sa pamamagitan ng paglikha ng object ng mapa bilang 'm1'. Ang listahan ng mapa ay may iba't ibang mga string ng mga key at ang mga halaga ng integer laban sa kanila. Pagkatapos, nai-print namin ang key na 'i' sa pamamagitan ng pagpasa nito sa mapa.at function. Ginamit namin ang try-catch block. Sa try block, ipinakita namin ang non-existence key sa mapa.at function. Dahil ang susi ay wala sa hanay, kaya ang try block ay magtapon ng error.
#include#include
gamit ang namespace std;
int pangunahing ( walang bisa ) {
mapa < char, int > m1 = {
{ 'l' , 1 } ,
{ 'ako' , dalawa } ,
{ 'n' , 3 } ,
{ 'sa' , 4 } ,
{ 'x' , 5 } ,
} ;
cout << 'value ng key ng mapa m1['i'] = ' << m1.at ( 'ako' ) << endl;
subukan {
m1.at ( 'Y' ) ;
} mahuli ( const out_of_range at at ) {
cerr << 'Error sa' << e.ano ( ) << endl;
}
bumalik 0 ;
}
Maaari naming mailarawan mula sa output screenshot na ang map.at() ibinabalik lamang ng function ang mga key na nasa mapa. Ang mga out-of-range na key ay nagtatapon ng error habang ipinapakita ang error kapag ipinasa namin ang key na 'y' sa mapa.at function.
Halimbawa 3: Paggamit ng map.at() Function para sa Pag-access sa Mga Elemento
Maaaring ma-access ang isang elemento gamit ang tinukoy na elemento ng mga digit mula sa function ng map.at. Ipatupad natin ang programang ito upang maisakatuparan ang pahayag sa itaas. Tinukoy muna namin ang module ng mapa sa seksyon ng header dahil kinakailangan itong ma-access ang mapa.at function. Pagkatapos, mayroon kaming pangunahing function kung saan sinimulan ng klase ng mapa ang object ng mapa bilang 'Map'. Gamit ang bagay na 'Map' na ito, nabuo namin ang mga key ng mga string at itinalaga ang halaga ng digit sa kanila. Pagkatapos noon, tinawagan namin ang mapa.at isang function na may cout statement at ipinasa ang 'Example' key bilang input.
#include#include
#include
gamit ang namespace std;
int pangunahing ( )
{
mapa < string, int > Mapa;
Mapa [ 'Aking' ] = 1 ;
Mapa [ 'c++' ] = dalawa ;
Mapa [ 'Mapa' ] = 3 ;
Mapa [ 'Halimbawa' ] = 4 ;
cout << Mapa.at ( 'Halimbawa' ) ;
bumalik 0 ;
}
Ang digit na elemento ay ibinalik laban sa tinukoy na key sa mapa.at function. Ang resulta ay nagbibigay ng halagang '4' dahil ang digit na ito ay itinalaga sa pangunahing elementong 'Halimbawa' ng isang mapa.
Halimbawa 4: Paggamit ng map.at() Function para sa Pagbabago ng mga Elemento
Isaalang-alang natin ang isang simpleng halimbawa ng pagbabago sa value na nauugnay sa key value. Nilikha namin ang listahan ng mapa sa pamamagitan ng pagtawag sa klase ng mapa at paglikha ng object na 'M1'. Nagtalaga kami ng string value laban sa bawat key ng mapa. Pagkatapos, kailangan nating gamitin ang mapa.at function. Nasa mapa.at function, ginamit namin ang mga tinukoy na key at itinalaga ang mga bagong string value laban sa mga key na iyon. Ngayon, ang mga halagang ito ay mababago sa nauna. Sa tulong ng for loop, inulit namin ang bawat elemento mula sa mapa at ipinakita ito bilang isang output.
#include#include
#include
gamit ang namespace std;
int pangunahing ( )
{
mapa < int, string > M1 = {
{ 10 , 'c++' } ,
{ dalawampu , 'java' } ,
{ 30 , 'python' } ,
{ 40 , 'csharp' } ,
{ limampu , 'BUKAS' } } ;
M1.at ( dalawampu ) = 'Tensorflow' ;
M1.at ( 30 ) = 'Linux' ;
M1.at ( limampu ) = 'Scala' ;
cout << ' \n Mga elemento:' << endl;
para sa ( sasakyan at x: M1 ) {
cout << x.una << ': ' << x.pangalawa << '\n' ;
}
bumalik 0 ;
}
Pansinin na ang mga value na nakuha bilang output ay nabago ang bagong itinalagang string value sa mapa.at function. Ang mga na-update na halaga ay ipinapakita sa snapshot sa ibaba.
Konklusyon
Ang artikulo ay tungkol sa mapa.at function. Ibinigay namin ang functionality ng map.at() function sa pamamagitan ng syntax nito at ang halimbawa ay ipinatupad gamit ang C++ compiler. Ang function na map.at() ay lubos na kapaki-pakinabang dahil nagbibigay-daan ito para sa accessibility ng elemento at nagbabalik ng malinaw na exception o error na naglalarawan sa sitwasyong lumitaw noong tinawag ang pamamaraan. Higit pa rito, maaari tayong magtalaga ng mga bagong value laban sa existence key sa pamamagitan ng map.at function.