I C++ er en vektor en allsidig beholder som dynamisk kan endre størrelsen på seg selv som muliggjør effektiv manipulering av elementer. Mens et par er en enkel beholder som kan inneholde to heterogene objekter som gir en praktisk måte å assosiere og administrere de relaterte dataene. Når disse parene er organisert i en vektor, får utviklerne muligheten til å lage de dynamiske samlingene av nøkkelverdi-par eller en hvilken som helst annen kombinasjon av to distinkte elementer.
Denne datastrukturen er spesielt nyttig i scenarier der elementene må lagres som par, for eksempel når man arbeider med nøkkelverdi-par eller representerer relasjonene mellom enheter. I denne artikkelen vil vi utforske konseptet med en C++-vektor av par og utforske de forskjellige eksemplene for å illustrere dens praktiske anvendelser.
Eksempel 1: Grunnleggende bruk: Iterering over en vektor av par
La oss vurdere et grunnleggende eksempel der vi lager en vektor av par som representerer elevnavnene og deres tilsvarende alder. Iterasjon over en vektor av par ligner på å iterere over en vanlig vektor. Man kan bruke enten iteratorene eller rekkeviddebaserte 'for'-løkker for å hente hvert par i vektoren.
Dette eksemplet viser syntaksen for en 'vektor av par' i en meningsfull kontekst.
#include
#inkluder
#inkludere
int main ( ) {
std::vektor < std::par < std::streng, int >> studentData;
studentData.push_back ( std::make_pair ( 'Adam' , tjue ) ) ;
studentData.push_back ( std::make_pair ( 'Regning' , 22 ) ) ;
studentData.push_back ( std::make_pair ( 'Charlie' , tjueen ) ) ;
std::cout << 'Studentdata: \n ' ;
til ( const auto & student : studentData ) {
std::cout << 'Navn: ' << student.først << ', Alder: ' << student.second << std::endl;
}
komme tilbake 0 ;
}
I denne C++-kodebiten begynner vi med å inkludere tre essensielle overskriftsfiler: «
Fremover, innenfor main()-funksjonen, erklærer vi en vektor kalt 'studentData' ved å bruke 'std::vector'-beholderen. Denne vektoren er designet for å lagre parene der hvert par innkapsler en elevs navn (representert som en 'std::streng') og deres alder (et 'int' heltall). Deretter fyller vi 'studentData'-vektoren med tre par. Ved å bruke 'push_back'-funksjonen legges par til på slutten av vektoren, og justerer dens størrelse dynamisk. En sløyfe går deretter gjennom 'studentData', trekker ut og skriver ut hver elevs navn og alder. Utdataene viser 'Student Data:' som understreker den strukturerte representasjonen. Elevens navn og alder skrives ut separat, og viser de lagrede dataene tydelig.
Eksempel 2: Sortering av en vektor av par
Sortering av en vektor av par er en vanlig operasjon, spesielt når man arbeider med nøkkel-verdi assosiasjoner. 'std::sort'-funksjonen fra '
#inkluder
#include
int main ( ) {
std::vektor < std::par < std::streng, int >> info;
info.push_back ( std::make_pair ( 'Peter' , femten ) ) ;
info.push_back ( std::make_pair ( 'Dora' , 29 ) ) ;
info.push_back ( std::make_pair ( 'Hanna' , tjue ) ) ;
std::cout << 'Original informasjon: \n ' ;
til ( const auto & oppføring : info ) {
std::cout << 'Navn: ' << entry.first << ', Alder: ' << entry.second << std::endl;
}
std::sort ( info.begin ( ) , info.end ( ) ) ;
std::cout << ' \n Sortert informasjon: \n ' ;
til ( const auto & oppføring : info ) {
std::cout << 'Alder: ' << entry.second << ', Navn: ' << entry.first << std::endl;
}
komme tilbake 0 ;
}
I dette C++-kodeeksemplet jobber vi med en vektor av par for å lagre og manipulere data relatert til individer, spesielt deres navn og alder. Vi initialiserer en vektor kalt 'info av par' i main()-funksjonen. Deretter fyller vi denne vektoren med tre par, som hver inneholder navnet og alderen til en distinkt person, ved å bruke 'push_back'-funksjonen og 'std::make_pair' for effektiv paroppretting.
Vi sender ut 'Original informasjon' til konsollen. Dette innebærer å iterere gjennom 'info'-vektoren og skrive ut hvert pars komponenter. Deretter bruker vi 'std::sort'-algoritmen for å omorganisere 'info'-vektoren basert på standard sammenligningsoperator for par som sammenligner det første elementet i hvert par (i dette tilfellet navnene). Etter sorteringsoperasjonen itererer vi igjen gjennom den modifiserte 'info'-vektoren ved å skrive ut den sorterte informasjonen. Denne gangen legger utgangen vekt på alder-første bestilling, og illustrerer resultatet av sorteringsprosessen.
Eksempel 3: Kombinere vektorer av forskjellige typer
Du kan støte på noen situasjoner der du må kombinere en informasjon fra to vektorer. En vektor av par kan bidra til å opprettholde assosiasjonen mellom elementer fra de to vektorene.
#include#inkluder
int main ( ) {
std::vektor < std::streng > byer = { 'New York' , 'Paris' , 'Tokyo' } ;
std::vektor < int > populasjoner = { 8175133 , 2140526 , 37435191 } ;
std::vektor < std::par < std::streng, int >> byPopulationPairs;
til ( size_t i = 0 ; Jeg < std::min ( byer.størrelse ( ) , populasjoner.størrelse ( ) ) ; ++i ) {
cityPopulationPairs.push_back ( { byer [ Jeg ] , populasjoner [ Jeg ] } ) ;
}
std::cout << 'By-befolkningspar:' << std::endl;
til ( const auto & par: cityPopulationPairs ) {
std::cout << 'By: ' << par.først << ', Befolkning: ' << par.sekund << std::endl;
}
komme tilbake 0 ;
}
I kodens 'hoved'-funksjon er to vektorer erklært: 'byer' for å lagre bynavnene og 'befolkninger' for å lagre de tilsvarende befolkningsverdiene.
En tredje vektor, 'cityPopulationPairs', er definert for å lagre byparene og deres respektive populasjoner. Hvert par er 'std::pair
Etter å ha kombinert informasjonen, brukes en annen 'for'-løkke for å iterere gjennom parene som er lagret i 'cityPopulationPairs'. De kombinerte dataene vises deretter på standardutgangen ved å bruke 'std::cout', som tydelig representerer hver by og dens korresponderende befolkning.
Eksempel 4: Finne maksimums- og minimumsverdier
Å identifisere minimums- og maksimumsverdiene i et datasett er et vanlig krav i algoritmiske og statistiske operasjoner. Vi kan bruke en vektor av par for å holde styr på både maksimums- og minimumsverdiene i en sekvens:
#include#inkluder
#include
int main ( ) {
std::vektor < int > tall = { 5 , 12 , 18 , 3 , 7 , 4 , 33 } ;
std::vektor < std::par < dere dere >> minMaxPairs;
std::sort ( tall.begynn ( ) , tall.slutt ( ) ) ;
minMaxPairs.push_back ( { tall.front ( ) , tall.tilbake ( ) } ) ;
std::cout << 'Min-maks-par:' << std::endl;
til ( const auto & par: minMaxPairs ) {
std::cout << 'Min: ' << par.først << ', Max: ' << par.sekund << std::endl;
}
komme tilbake 0 ;
}
Den medfølgende C++-koden demonstrerer prosessen med å finne minimums- og maksimumsverdiene i en vektor av heltall og deretter lagre disse verdiene i en vektor av par. En vektor kalt 'tall' er i utgangspunktet deklarert og initialisert med et sett med heltall. For å effektivt identifisere minimums- og maksimumsverdiene i datasettet, bruker programmet 'std::sort'-funksjonen fra algoritmebiblioteket.
Denne funksjonen tar sikte på å ordne elementene i stigende rekkefølge, og forenkle prosessen med å identifisere både minimums- og maksimumsverdiene i datasettet. Sorteringsoperasjonen brukes på 'numbers'-vektoren ved å bruke numbers.begin() og numbers.end() som områdeparametere. Etter sorteringstrinnet oppretter programmet en vektor av par, 'minMaxPairs', for å lagre de beregnede minimums- og maksimumsverdiene. 'Push_back'-funksjonen brukes deretter for å legge til et enkelt par som inneholder den sorterte tallvektorens første (minimum) og siste (maksimum) elementer. Til slutt gir programmet ut resultatet ved å iterere gjennom 'minMaxPairs'-vektoren og vise minimums- og maksimumsverdiene.
Konklusjon
Avslutningsvis fremstår C++-vektoren av par som en kraftig og fleksibel datastruktur, og legger til et lag med allsidighet til programmeringsoppgaver. Gjennom en detaljert utforskning av dens syntaks og praktiske anvendelser, har vi sett hvordan denne beholderen hjelper til med å organisere nøkkelverdi-assosiasjonene, kombinere informasjonen fra forskjellige vektorer og spore minimums- og maksimumsverdiene.