iterators stl
En komplett oversikt over Iteratorer i STL.
I denne opplæringen vil vi se på detaljene til iteratorer, deres typer, fordeler og de forskjellige funksjonene de støtter.
nettutviklerintervju spørsmål og svar
Hva er en Iterator? Generelt er en iterator akkurat som ethvert objekt som peker på et bestemt element i en rekke data som en matrise eller en container. En iterator er akkurat som en peker i C.
=> Se etter hele C ++ treningsserien her.
Hva du vil lære:
Oversikt
I STL er en iterator et objekt som kan brukes til å krysse gjennom eller gå gjennom elementene i beholderen ved å bruke et sett med operatorer som inkrement operator (++) eller dereference operator (*).
Iteratorer er avgjørende i STL-programmering, da de spiller en viktig rolle i å koble algoritmene til beholderen i tillegg til å få tilgang til og manipulere dataene som er lagret i containerne.
Typer Iteratorer
Avhengig av funksjonaliteten implementert av iteratorene, klassifiseres de som følger:
- Input og Output Iteratorer : Dette er de mest forenklede typene iteratorer. De er mest nyttige i sekvensielle inngangs- og utgangsoperasjoner som inneholder enkeltpass.
- Fremover Iteratorer : Disse er akkurat som inndata-iteratorer, men har en retning, dvs. fremoverretning i den forstand at de kan brukes til å krysse gjennom et område i videresendingsretningen. Når fremover iteratorer ikke er konstante, kan de også brukes som utgang iteratorer. De fleste standard STL-containere støtter i det minste fremover iteratorer.
- Toveis Iteratorer : Disse ligner på videresendende iteratorer med den eneste forskjellen at de er toveis. Dette betyr at vi kan bruke disse toveis iteratorene til å krysse gjennom området både fremover og bakover.
- Tilfeldige tilgangsteratorer : Tilfeldig tilgang iteratorer er kraftigste blant alle iteratorene. Dette er ikke-sekvensielle iteratorer. Tilfeldige tilgang iteratorer tillater oss å få tilgang til hvilken som helst tilfeldig verdi ved å bruke en forskyvning til den nåværende verdien uten å måtte passere gjennom hvert element sekvensielt. De har lignende egenskaper som Pointers in C.
En ting å merke seg er at ikke alle STL-containere støtter alle iteratorene. Ulike containere støtter forskjellige iteratorer, avhengig av kravet til funksjonalitet.
Nedenfor er listen over containere som bruker forskjellige iteratorer:
Beholdere | Iteratorer |
---|---|
Kart | Toveis |
Stable | Ingen iterator |
Kø | Ingen iterator |
Prioritetskø | Ingen iterator |
Liste | Toveis |
Vector | Tilfeldig tilgang |
og | Tilfeldig tilgang |
Multimap | Toveis |
Sett | Toveis |
Multisett | Toveis |
Fordeler med Iteratorer
Iteratorer er ekstremt nyttige, spesielt når de programmerer med forskjellige områder og containere.
Noen av fordelene ved å bruke iteratorer i programmering kan oppsummeres nedenfor:
# 1) Kodenes gjenbrukbarhet
Så lenge vi bruker iteratorer for å få tilgang til elementer i programmet vårt, kan vi bare endre navnet på containeren i vår iterator-definisjon og bruke resten av koden på en lignende måte når vi trenger å endre containeren.
Dette er spesielt nyttig i scenarier der vi planlegger å erstatte en vektorbeholder ved hjelp av en listebeholder. Hvis vi brukte [] -operatøren i stedet for iteratorer, ville koden for å få tilgang til elementer være ubrukelig når vi bytter container.
# 2) Enkelhet og bekvemmelighet ved programmering
Iteratorer kommer med forskjellige innebygde funksjoner som hjelper oss med å krysse og få tilgang til innholdet i containeren enkelt og praktisk.
For eksempel , vi trenger ikke fortsette å sjekke slutten av listen eller array-lignende vi må gjøre mens vi bruker [] operatorer, og vi trenger å endre programkoden som når vi vil legge til elementer, og vi må endre dem for en loop .
Når du bruker iteratorer, kan vi få direkte tilgang til start- () og end () -funksjonene til iteratorene uten å måtte holde en fane når vi når slutten av listen, og vi trenger heller ikke endre dem for en løkke.
# 3) Dynamisk legg til / fjern
Når vi bruker iteratorer, kan vi enkelt og dynamisk legge til eller fjerne elementene i beholderen uten å måtte flytte elementene slik vi må gjøre i [] -operatører.
La oss demonstrere dette med følgende eksempel:
#include #include using namespace std; int main() { vector vec1 = { 1, 1, 2 }; // Declaring an iterator vector::iterator i; // Inserting element for (i = vec1.begin(); i != vec1.end(); ++i) { if (i == vec1.begin()) { i = vec1.insert(i, 3); // insert 3 at the beginning of vec1 } } // contents of vec1 3 1 1 2 cout<<'Vector contents after addition'; cout< Produksjon:
Vektorinnhold etter tilsetning
3 1 1 2
Vektorinnhold etter sletting
3 1 2
Som vist i eksemplet ovenfor ser vi at ved hjelp av iteratorer kan vi enkelt legge til eller fjerne elementer fra en container (vektor i dette tilfellet), uten å måtte ty til den komplekse programmeringen av skiftende elementer og omstrukturering av containeren.
Iteratorfunksjoner
Ettersom iteratorer i seg selv er innebygde konstruksjoner, støtter de forskjellige operasjoner som kan gjøres på iteratorobjekter. Disse operasjonene / funksjonene lar oss effektivt krysse området og også manipulere elementene inne i containeren.
Nå vil vi se noen store operasjoner som iteratorer støtter.
- begynne: Returnerer iteratorens første eller startposisjon.
- slutt: Returnerer den siste posisjonen eller 'etter endeposisjonen' til iteratoren.
- forrige: Returnerer den nye iteratoren etter å ha redusert antall posisjoner gitt i argumentet.
- neste: Returnerer ny iterator etter å ha kommet frem eller økt antall posisjoner gitt i argumentet.
- innsetter: Setter inn element i en hvilken som helst posisjon i en container.
- avansere: Øker iteratorposisjonen til det angitte tallet gitt i argumentet.
Vi vil demonstrere bruken av noe av denne funksjonen / operasjonen i følgende program:
#include #include #include using namespace std; int main() { vector v = { 1, 1,2,3,5 }; // declaring iterators to a vector vector::iterator itr1 = v.begin(); vector::iterator itr2 = v.end(); auto it = next(itr1, 2); // displaying iterator position cout << 'Using next() the new iterator is at: '; cout << *it << ' '; cout << endl; auto it1 = prev(itr2, 2); // displaying iterator position cout << 'The position of new iterator using prev() is: '; cout << *it1 << ' '; cout << endl; //advance advance(itr1,3); // displaying iterator position cout << 'After advance operation,itr1 is positioned at: '; cout << *itr1 << ' '; cout << endl; return 0; }
Produksjon:
Ved hjelp av neste () er den nye iteratoren på: 2
Posisjonen til den nye iteratoren som bruker prev () er: 3
Etter forhåndsoperasjonen er itr1 plassert på: 3
Ved å bruke programmet ovenfor har vi demonstrert bruken av forskjellige iteratoroperasjoner.
Konklusjon
Dermed har vi kommet til slutten av denne opplæringen om Iterators.
Så langt har vi diskutert det grunnleggende om STL, fra neste opplæring vil vi begynne med STL-containere og deres programmering.
=> Sjekk Komplett C ++ GRATIS treningsserie her.
Anbefalt lesing