Sa C++, ang vector ay isang versatile na lalagyan na maaaring dynamic na baguhin ang laki nito na nagbibigay-daan para sa mahusay na pagmamanipula ng mga elemento. Habang ang isang pares ay isang simpleng lalagyan na maaaring maglaman ng dalawang magkaibang bagay na nagbibigay ng maginhawang paraan upang iugnay at pamahalaan ang nauugnay na data. Kapag nakaayos ang mga pares na ito sa loob ng isang vector, magkakaroon ang mga developer ng kakayahang gumawa ng mga dynamic na koleksyon ng mga pares ng key-value o anumang iba pang kumbinasyon ng dalawang natatanging elemento.
Ang istruktura ng data na ito ay partikular na kapaki-pakinabang sa mga sitwasyon kung saan ang mga elemento ay dapat na naka-imbak bilang mga pares tulad ng kapag nakikitungo sa mga pares ng key-value o kumakatawan sa mga ugnayan sa pagitan ng mga entity. Sa artikulong ito, tutuklasin natin ang konsepto ng isang C++ vector ng mga pares at tuklasin ang iba't ibang mga halimbawa upang ilarawan ang mga praktikal na aplikasyon nito.
Halimbawa 1: Pangunahing Paggamit: Pag-ulit sa Isang Vector ng Mga Pares
Isaalang-alang natin ang isang pangunahing halimbawa kung saan gumagawa tayo ng vector ng mga pares na kumakatawan sa mga pangalan ng mag-aaral at sa kanilang mga katumbas na edad. Ang pag-ulit sa isang vector ng mga pares ay katulad ng pag-ulit sa isang regular na vector. Maaaring gamitin ng isa ang alinman sa mga iterator o nakabatay sa saklaw na 'para sa' mga loop upang makuha ang bawat pares sa loob ng vector.
Ang halimbawang ito ay nagpapakita ng syntax para sa isang 'vector ng mga pares' sa isang makabuluhang konteksto.
#include
#include
#include
int pangunahing ( ) {
std::vector < std::pares < std::string, int >> studentData;
studentData.push_back ( std::make_pair ( 'Adam' , dalawampu ) ) ;
studentData.push_back ( std::make_pair ( 'Bill' , 22 ) ) ;
studentData.push_back ( std::make_pair ( 'Charlie' , dalawampu't isa ) ) ;
std::cout << 'Data ng Mag-aaral: \n ' ;
para sa ( const auto at mag-aaral : studentData ) {
std::cout << 'Pangalan: ' << mag-aaral.una << ', Edad: ' << mag-aaral.pangalawa << std::endl;
}
bumalik 0 ;
}
Sa snippet ng C++ code na ito, magsisimula kami sa pamamagitan ng pagsasama ng tatlong mahahalagang header file: “
Sa pasulong, sa loob ng main() function, idedeklara namin ang isang vector na pinangalanang 'studentData' gamit ang 'std::vector' container. Ang vector na ito ay idinisenyo upang iimbak ang mga pares kung saan ang bawat pares ay naka-encapsulate ng pangalan ng isang mag-aaral (kinakatawan bilang isang 'std::string') at ang kanilang edad (isang 'int' integer). Pagkatapos, pinupuno namin ang vector ng 'studentData' na may tatlong pares. Gamit ang function na 'push_back', idinaragdag ang mga pares sa dulo ng vector, dynamic na inaayos ang laki nito. Ang isang loop pagkatapos ay umuulit sa pamamagitan ng 'studentData', pagkuha at pag-print ng pangalan at edad ng bawat mag-aaral. Ang output ay nagpapakita ng 'Data ng Mag-aaral:' na nagbibigay-diin sa nakabalangkas na representasyon. Ang mga pangalan at edad ng mag-aaral ay naka-print nang hiwalay, malinaw na ipinapakita ang nakaimbak na data.
Halimbawa 2: Pag-uuri ng Vector ng mga Pares
Ang pag-uuri ng isang vector ng mga pares ay isang karaniwang operasyon, lalo na kapag nakikitungo sa mga asosasyon ng key-value. Ang function na 'std::sort' mula sa header na '
#include
#include
int pangunahing ( ) {
std::vector < std::pares < std::string, int >> impormasyon;
info.push_back ( std::make_pair ( 'Peter' , labinlima ) ) ;
info.push_back ( std::make_pair ( 'Dora' , 29 ) ) ;
info.push_back ( std::make_pair ( 'Hanna' , dalawampu ) ) ;
std::cout << 'Orihinal na Impormasyon: \n ' ;
para sa ( const auto at entry: impormasyon ) {
std::cout << 'Pangalan: ' << pagpasok.una << ', Edad: ' << pagpasok.pangalawa << std::endl;
}
std::uri ( impormasyon.magsimula ( ) , info.end ( ) ) ;
std::cout << ' \n Pinagsunod-sunod na Impormasyon: \n ' ;
para sa ( const auto at entry: impormasyon ) {
std::cout << 'Edad:' << pagpasok.pangalawa << ', Pangalan: ' << pagpasok.una << std::endl;
}
bumalik 0 ;
}
Sa halimbawang C++ code na ito, nakikipagtulungan kami sa isang vector ng mga pares upang iimbak at manipulahin ang data na nauugnay sa mga indibidwal, partikular ang kanilang mga pangalan at edad. Sinisimulan namin ang isang vector na pinangalanang 'impormasyon ng mga pares' sa loob ng main() function. Kasunod nito, pinupuno namin ang vector na ito ng tatlong pares, bawat isa ay naglalaman ng pangalan at edad ng isang natatanging tao, gamit ang function na 'push_back' at 'std::make_pair' para sa mahusay na paggawa ng pares.
Inilalabas namin ang 'Orihinal na Impormasyon' sa console. Kabilang dito ang pag-ulit sa pamamagitan ng vector ng 'impormasyon' at pag-print ng mga bahagi ng bawat pares. Pagkatapos, ginagamit namin ang algorithm na 'std::sort' upang muling ayusin ang vector na 'impormasyon' batay sa default na operator ng paghahambing para sa mga pares na naghahambing sa unang elemento ng bawat pares (sa kasong ito, ang mga pangalan). Kasunod ng pagpapatakbo ng pag-uuri, muli kaming umulit sa binagong 'impormasyon' na vector sa pamamagitan ng pag-print ng pinagsunod-sunod na impormasyon. Sa pagkakataong ito, binibigyang-diin ng output ang pag-order na una sa edad, na naglalarawan ng resulta ng proseso ng pag-uuri.
Halimbawa 3: Pagsasama-sama ng mga Vector ng Iba't ibang Uri
Maaari kang makatagpo ng ilang sitwasyon kung saan dapat mong pagsamahin ang isang impormasyon mula sa dalawang vectors. Ang isang vector ng mga pares ay maaaring makatulong na mapanatili ang kaugnayan sa pagitan ng mga elemento mula sa dalawang vectors.
#include#include
int pangunahing ( ) {
std::vector < std::string > lungsod = { 'New York' , 'Paris' , 'Tokyo' } ;
std::vector < int > populasyon = { 8175133 , 2140526 , 37435191 } ;
std::vector < std::pares < std::string, int >> cityPopulationPairs;
para sa ( laki_t i = 0 ; i < std::min ( lungsod.laki ( ) , populasyon. laki ( ) ) ; ++i ) {
cityPopulationPairs.push_back ( { mga lungsod [ i ] , populasyon [ i ] } ) ;
}
std::cout << 'Pares ng Lungsod-Populasyon:' << std::endl;
para sa ( const auto at pares : cityPopulationPairs ) {
std::cout << 'Lungsod:' << pares.una << ', Populasyon: ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Sa 'pangunahing' function ng code, dalawang vector ang idineklara: 'mga lungsod' upang iimbak ang mga pangalan ng lungsod at 'populasyon' upang iimbak ang mga katumbas na halaga ng populasyon.
Ang ikatlong vector, 'cityPopulationPairs', ay tinukoy upang iimbak ang mga pares ng mga lungsod at kani-kanilang mga populasyon. Ang bawat pares ay “std::pair
Pagkatapos pagsamahin ang impormasyon, isa pang 'para sa' loop ang ginagamit upang umulit sa mga pares na naka-imbak sa 'cityPopulationPairs'. Ang pinagsamang data ay ipapakita sa karaniwang output gamit ang 'std::cout', na malinaw na kumakatawan sa bawat lungsod at sa kaukulang populasyon nito.
Halimbawa 4: Paghahanap ng Pinakamataas at Pinakamababang Halaga
Ang pagtukoy sa minimum at maximum na mga value sa loob ng isang dataset ay isang karaniwang kinakailangan sa algorithmic at statistical operations. Maaari kaming gumamit ng vector ng mga pares upang masubaybayan ang parehong maximum at minimum na mga halaga sa isang pagkakasunud-sunod:
#include#include
#include
int pangunahing ( ) {
std::vector < int > mga numero = { 5 , 12 , 18 , 3 , 7 , 4 , 33 } ;
std::vector < std::pares < ikaw, ikaw >> minMaxPairs;
std::uri ( mga numero.simulan ( ) , numbers.end ( ) ) ;
minMaxPairs.push_back ( { mga numero.harap ( ) , numero.likod ( ) } ) ;
std::cout << 'Min-Max na Pares:' << std::endl;
para sa ( const auto at pares: minMaxPairs ) {
std::cout << 'Min: ' << pares.una << ', Max: ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Ang ibinigay na C++ code ay nagpapakita ng proseso ng paghahanap ng minimum at maximum na mga halaga sa isang vector ng mga integer at pagkatapos ay iimbak ang mga halagang ito sa isang vector ng mga pares. Ang isang vector na pinangalanang 'mga numero' ay unang idineklara at sinisimulan sa isang hanay ng mga integer. Upang mahusay na matukoy ang minimum at maximum na mga halaga sa dataset, ginagamit ng program ang function na 'std::sort' mula sa library ng algorithm.
Nilalayon ng function na ito na ayusin ang mga elemento sa pataas na pagkakasunud-sunod, na pinapasimple ang proseso ng pagtukoy sa parehong minimum at maximum na mga halaga sa dataset. Ang pagpapatakbo ng pag-uuri ay inilalapat sa vector ng 'mga numero' gamit ang mga numero.begin() at numbers.end() bilang mga parameter ng hanay. Kasunod ng hakbang sa pag-uuri, ang programa ay lumilikha ng isang vector ng mga pares, 'minMaxPairs', upang iimbak ang kinakalkula na minimum at maximum na mga halaga. Ang function na 'push_back' ay ginagamit upang magdagdag ng isang pares na naglalaman ng una (minimum) at huling (maximum) na elemento ng vector ng pinagsunod-sunod na numero. Sa wakas, ang programa ay naglalabas ng resulta sa pamamagitan ng pag-ulit sa pamamagitan ng 'minMaxPairs' vector at pagpapakita ng pinakamababa at pinakamataas na halaga.
Konklusyon
Sa konklusyon, ang C++ vector ng mga pares ay lumalabas bilang isang makapangyarihan at nababaluktot na istraktura ng data, na nagdaragdag ng isang layer ng versatility sa mga gawain sa programming. Sa pamamagitan ng isang detalyadong pag-explore ng syntax at praktikal na mga aplikasyon nito, nakita namin kung paano nakakatulong ang container na ito upang ayusin ang mga asosasyon ng key-value, pagsamahin ang impormasyon mula sa iba't ibang vector, at subaybayan ang minimum at maximum na mga value.