En  Iterator i C ++  er et markørlignende objekt, der peger på et element i STL-beholderen. De bruges generelt til at slukke gennem indholdet af STL -beholderen i C ++. Den største fordel ved STL -iteratorer er, at de gør STL -algoritmerne uafhængige af den anvendte container. Vi kan bare videregive iteratoren til containerelementerne i stedet for containeren selv til STL -algoritmerne.

Iterator -erklæring

Hver container i C ++ STL har sin egen iterator. Så vi er nødt til at erklære en iterator som:

<type>::iterator it; 

hvor

• type: Type container, som iteratoren er erklæret for.
• det: Navn tildelt iteratorobjekt.

Vi kan derefter initialisere det ved at tildele en gyldig iterator. Hvis vi allerede har en iterator, der skal tildeles på tidspunktet for delcaration, kan vi springe over typen ved hjælp af Auto nøgleord.

auto it = iter 

hvor iter er iteratoren tildelt den nyoprettede it -iterator.

Vores C ++ kursus Dækker brugen af ​​iteratorer i STL, hvilket sikrer, at du forstår, hvordan du krydser forskellige contaertyper.

Eksempel på iteratorer

Nedenstående program illustrerer, hvordan man bruger iteratoren til at krydse 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 måske har bemærket, at vi har brugt Vector :: Begin () og Vector :: END () fungere. Disse funktioner er medlemsfunktionerne til std :: vektor, der returnerer iteratoren til det første og det ene element efter det sidste element i vektoren. Vi bruger iteratorerne returnerer være disse funktioner til at iterere vektorerne.

Container -iteratorfunktioner

C ++ STL leverer nogle medlemsfunktioner i STL -container Det returnerer iteratorerne til mindst det første og det sidste element. Disse medlemsfunktioner er defineret i næsten hele STL -containeren (efterlader nogle begrænsede adgangscontainere som stak kø ) med samme navn for konsistens.

Følgende tabel viser alle metoder, der returnerer iteratoren til containerne:

For eksempel hvis En ting er navnet på vektoren, så kan vi bruge ovenstående metoder som vist nedenfor:

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

Iterators operationer

Ligesom markøraritmetik er der nogle operationer, der er tilladt på C ++ iteratorer. De bruges til at give forskellige funktionaliteter, der øger iteratorens betydning. Der er 5 gyldige Iteratoroperationer i C ++ :

• Derferencing iterators
• Forøgelse/dekrementerende iteratorer
• Tilføjelse/subtraktion af heltal til iteratorer
• Trækker en anden iterator
• Sammenligning af iteratorer

Derferencing iterators

Dererencing -operation giver brugerne mulighed for at adgang eller opdatering Værdien af ​​det element, der er peget af iteratoren. Vi bruger (*) Indirekte operatør til derferens iteratorer ligesom pointers.

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

hvor New_Val er den nye værdi, der er tildelt det element, der er peget af iterator det .

Forøgelse/dekrementerende iteratorer

Vi kan øge eller reducere iteratoren med 1 ved hjælp af (++) eller (-) operatører henholdsvis. Forøgelsesoperation flytter iteratoren til det næste element i beholderen, mens dekrementoperationen flytter iteratoren til det forrige element.

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

Tilføjelse/subtraktion af heltal til iteratorer

Vi kan også tilføje eller trække en heltalværdi fra iteratorerne. Det vil mere iteratoren næste eller tidligere position i henhold til den ekstra heltalværdi.

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

hvor INT_VAL er heltalværdierne, der tilføjes eller trækkes fra iteratoren det .

Trækker en anden iterator

Vi kan trække en iterator fra en anden for at finde afstanden (eller antallet af elementer) mellem den hukommelse, de peger på.

it1 - it2 

Sammenligning af iteratorer

Vi kan også teste de to iteratorer af samme type mod hinanden for at finde forholdet mellem dem. Vi kan bruge de relationelle operatører som (==) ligestilling og (! =) Ulighedsoperatører sammen med andre relationelle operatører, såsom< > <= >=.

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 af iteratorer i C ++

STL iteratorer kan opdeles på grundlag af de operationer, der kan udføres på dem. Der er 5 hovedtyper af iteratorer i C ++, som som anført i nedenstående tabel sammen med understøttede containere og understøttede iteratoroperationer.

Som vi måske har bemærket fra ovenstående tabel bortset fra input- og output -iteratorerne Når vi går ned på bordet, indeholder iteratortypen funktionerne på ovenstående iterator sammen med nogle nye funktioner.

Iteratoradaptere

Iteratoradaptere i C ++ er den specielle type iteratorer, der er bygget over traditionelle iteratorer til at give specialiseret funktionalitet. Der er mange iteratoradaptere i C ++, hvoraf nogle er angivet nedenfor:

Iterator -værktøjsfunktioner i C ++

C ++ STL leverer de forskellige funktioner til at forenkle arbejdet med iteratorer. De er anført i nedenstående tabel:

Anvendelser af iteratorer med eksempler

Iteratorer bruges i vid udstrækning i C ++ til mange forskellige formål, mens de arbejder med STL -containere og algoritmer. Følgende er nogle primære anvendelser af iteratorer i C ++, som deres kodeeksempler:

Krydse containere

Traversing STL -containere er den mest basale anvendelse af iteratorer. I dette bruger vi start () og slut () -funktionerne for at få start- og afsluttende iteratorer til at krydse hele beholderen. Grundlæggende fortsætter vi med at øge begyndelsen af ​​iteratoren, indtil den ikke er lig med slutningen.

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 ovenfor krydser vi sætcontaineren. Tilsvarende kan vi bruge den samme tilgang til at krydse enhver beholder.

Vende en beholder

Omvendt iteratorer giver dig mulighed for at krydse en container fra slutningen til begyndelsen uden at skulle manuelt håndtere reverseringen.

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 

Containeruafhængige algoritmer

Iteratorer tillader algoritmer at arbejde med enhver contaertype -funktionsfunktioner som std :: sortering () std :: find () og std :: for_each () mere fleksibel. Du kan passere iteratorer i stedet for den faktiske beholder.

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

Yderligere anvendelser af iteratorer

Der er flere anvendelser af STL -iteratorer:

• Afstandsberegning: Brug af std :: afstand () iteratorer hjælper med at beregne antallet af elementer mellem to positioner i en container.
• Stream iteration: Stream iteratorer giver dig mulighed for at behandle input/outputstrømme som containere, hvilket gør det lettere at læse fra og skrive til streams ved hjælp af STL -algoritmer.
• Flyt semantik i STL -algoritmer: Flyt iteratorer introducerer Move Semantics i STL -algoritmer, som hjælper med at øge ydeevnen og effektiviteten ved at undgå unødvendig kopiering. Dataene flyttes i henhold til reglerne for Move Semantics.
• Brugerdefinerede iteratorer til datastrukturer: Brugerdefinerede iteratorer kan implementeres til ikke-STL-datastrukturer som træer eller grafer for at yde støtte til STL-algoritmer og mange andre funktioner. Vi er muligvis nødt til at følge et par sæt regler og konventioner for at give ordentlig forøgelse af dekrementering og andre operationer.