An  iterator i C ++  er et pekerlignende objekt som peker på et element i STL-beholderen. De brukes vanligvis til å sløyfe gjennom innholdet i STL -beholderen i C ++. Den største fordelen med STL -iteratorer er at de gjør STL -algoritmene uavhengig av typen beholder som brukes. Vi kan bare overføre iteratoren til beholderelementene i stedet for selve beholderen til STL -algoritmene.

Iteratorerklæring

Hver beholder i C ++ STL har sin egen iterator. Så vi må erklære en iterator som:

<type>::iterator it; 

hvor

• type: Type beholder som iteratoren er erklært for.
• den: Navn tildelt iteratorobjekt.

Vi kan deretter initialisere den ved å tilordne noen gyldig iterator. Hvis vi allerede har en iterator som skal tildeles på delingstidspunktet, kan vi hoppe over typedeklarasjonen ved å bruke bil nøkkelord.

auto it = iter 

hvor iter er iteratoren tildelt den nyopprettede iteratoren.

Vår C ++ kurs Dekker bruken av iteratorer i STL som sikrer at du forstår hvordan du krysser forskjellige containertyper.

Eksempel på iteratorer

Programmet nedenfor illustrerer hvordan du bruker iteratoren til å krysse vektorbeholderen:

#include    using namespace std; int main() {  vector<int> v = {1 2 3 4 5};  // Defining an iterator pointing to  // the beginning of the vector  vector<int>::iterator first =  v.begin();  // Defining an iterator pointing  // to the end of the vector  vector<int>::iterator last =  v.end();    // Iterating the whole vector  while(first != last) {  cout << *first << ' ';  first++;  }  return 0; } 

1 2 3 4 5 

Som du kanskje har lagt merke til at vi har brukt Vector :: Begin () og Vector :: End () funksjon. Disse funksjonene er medlemsfunksjonene til std :: vektor som returnerer iteratoren til det første og ett element etter det siste elementet i vektoren. Vi bruker iteratorene returnerer være disse funksjonene for å iterere vektorene.

Container iteratorfunksjoner

C ++ STL gir noen medlemsfunksjoner i STL -beholder som returnerer iteratorene til minst det første og det siste elementet. Disse medlemsfunksjonene er definert i nesten alle STL -beholderen (etterlater noen begrensede tilgangsbeholdere som stable kø ) med samme navn for konsistens.

Følgende tabell viser alle metoder som returnerer iteratoren til beholderne:

For eksempel hvis en ting er navnet på vektoren, så kan vi bruke metodene ovenfor som vist nedenfor:

vec.begin() vec.rbegin() vec.cbegin() vec.crbegin() vec.end() vec.rend()  vec.cend() vec.crend() 

Iteratorer operasjoner

Akkurat som peker aritmetikk er det noen operasjoner som er tillatt på C ++ iteratorer. De brukes til å gi forskjellige funksjoner som øker viktigheten av iteratorer. Det er 5 gyldige iteratoroperasjoner i C ++ :

• Dereferencing iteratorer
• Økt/reduserende iteratorer
• Legge til/trekke heltall til iteratorer
• Trekker en annen iterator
• Sammenligne iteratorer

Dereferencing iteratorer

Dereferencing -operasjon lar brukerne tilgang eller oppdatering verdien av elementet som iteratoren peker. Vi bruker (*) indireksjonsoperatør til Dereference iteratorer akkurat som pekere.

// Access *it; // Update *it = new_val;  

hvor new_val er den nye verdien tildelt elementet som iterator er pekt den .

Økt/reduserende iteratorer

Vi kan øke eller redusere iteratoren ved å bruke (++) eller (-) operatører henholdsvis. Økningsoperasjon flytter iteratoren til neste element i beholderen mens reduksjonsoperasjonen flytter iteratoren til det forrige elementet.

it++; // post-increment ++it; // pre-increment it--; // post-decrement --it; // pre-decrement 

Legge til/trekke heltall til iteratorer

Vi kan også legge til eller trekke fra en heltallverdi fra iteratorene. Det vil mer iteratoren neste eller forrige stilling i henhold til den ekstra heltallverdien.

// Addition it + int_val;  // Subtraction it - int_val;  

hvor int_val er heltallverdiene som blir lagt til eller trukket fra iteratoren den .

Trekker en annen iterator

Vi kan trekke en iterator fra en annen for å finne avstanden (eller antall elementer) mellom minnet de peker på.

it1 - it2 

Sammenligne iteratorer

Vi kan også teste de to iteratorene av samme type mot hverandre for å finne forholdet mellom dem. Vi kan bruke de relasjonelle operatørene som (==) likhet og (! =) Ulikhetsoperatører sammen med andre relasjonelle operatører som for eksempel< > <= >=.

it1 != it2 // Equal to it1 == it2 // Not equal to it1 > it2 // Greater than it1 < it2 // Less than it1 >= it2 // Greater than equal to it1 <= it2 // Less than equal to 

Typer iteratorer i C ++

Stl iteratorer kan deles på grunnlag av operasjonene som kan utføres på dem. Det er 5 hovedtyper av iteratorer i C ++ som som er oppført i tabellen nedenfor sammen med støttede containere og støttede iteratoroperasjoner.

Som vi kanskje har lagt merke til fra tabellen ovenfor, bortsett fra inngangs- og output -iteratorene Når vi går nedover bordet, inneholder iteratortypen funksjonene til ovenfor iterator sammen med noen nye funksjoner.

Iteratoradaptere

Iteratoradaptere i C ++ er den spesielle typen iteratorer som er bygget over tradisjonelle iteratorer for å gi spesialisert funksjonalitet. Det er mange iteratoradaptere i C ++ hvorav noen er gitt nedenfor:

Iterator verktøyfunksjoner i C ++

C ++ STL gir den forskjellige funksjonen for å forenkle arbeidene med iteratorer. De er oppført i tabellen nedenfor:

Applikasjoner av iteratorer med eksempler

Iteratorer brukes omfattende i C ++ for mange forskjellige formål mens de arbeider med STL -containere og algoritmer. Følgende er noen primære applikasjoner av iteratorer i C ++ som kodeeksemplene deres:

Kryssende containere

Å krysse STL -containere er den mest grunnleggende anvendelsen av iteratorer. I dette bruker vi BEGIN () og END () -funksjonene for å få start- og End -iteratorene for å krysse hele beholderen. I utgangspunktet øker vi begynnelsen av iteratoren før den ikke er lik slutten.

Eksempel

#include    using namespace std; int main() {  set<int> s = {10 20 30   40 50};  // Iterator to the beginning   // of the set  auto it = s.begin();  // Iterating through the   // entire set  while (it != s.end()) {    // Dereferencing iterator   // to access value  cout << *it << ' ';    // Incrementing the   // iterator  it++;  }    return 0; } 

10 20 30 40 50 

Som vist i koden over krysser vi settbeholderen. På samme måte kan vi bruke den samme tilnærmingen for å krysse enhver beholder.

Reverserer en beholder

Omvendt iteratorer lar deg krysse en beholder fra slutten til begynnelsen uten å måtte håndtere reversering manuelt.

Eksempel

#include    using namespace std; int main() {  vector<int> vec = {10 20 30   40 50};  // Defining reverse iterators   // pointing to the reverse   // beginning of vec  auto it = vec.rbegin();  // Iterating the whole   // vector in reverse  while (it != vec.rend()) {  cout << *it << ' ';  it++;  }  return 0; } 

50 40 30 20 10 

Container-uavhengige algoritmer

Iteratorer lar algoritmer jobbe med alle containertype som lager funksjoner som std :: sort () std :: find () og std :: for_each () mer fleksibel. Du kan passere iteratorer i stedet for den faktiske beholderen.

Eksempel

#include    using namespace std; int main() {  vector<int> vec = {30 10 40   10 50};  multiset<int> ms = {10 30 10   20 40 10};  // Using the std::count() algorithm to count  // the number of occurences of 10 in vector  // and multiset using iterator  cout << '10s in Vector: '   << count(vec.begin()  vec.end() 10) << endl;  cout << '10s in Multiset: '   << count(ms.begin()  ms.end() 10);  return 0; } 

10s in Vector: 2 10s in Multiset: 3

Ytterligere applikasjoner av iteratorer

Det er flere applikasjoner av STL -iteratorer:

• Avstandsberegning: Bruke STD :: avstand () iteratorer er med på å beregne antall elementer mellom to posisjoner i en beholder.
• Strøm iterasjon: Stream iteratorer lar deg behandle inngangs-/utgangsstrømmer som containere som gjør det lettere å lese fra og skrive til strømmer ved hjelp av STL -algoritmer.
• Flytt semantikk i STL -algoritmer: Flytt iteratorer introduserer MOVE -semantikken i STL -algoritmer som hjelper til med å øke ytelsen og effektiviteten ved å unngå unødvendig kopiering. Dataene vil bli flyttet i henhold til reglene for Move Semantics.
• Tilpassede iteratorer for datastrukturer: Tilpassede iteratorer kan implementeres for ikke-STL-datastrukturer som trær eller grafer for å gi støtte for STL-algoritmer og mange andre funksjoner. Det kan hende at vi må følge noen få regler og konvensjoner for å gi riktig økende dekrementering og annen virksomhet.