En  iterator i C ++  är ett pekarliknande objekt som pekar på ett element i STL-behållaren. De används vanligtvis för att slinga genom innehållet i STL -behållaren i C ++. Den största fördelen med STL -iteratorer är att de gör STL -algoritmerna oberoende av den typ av behållare som används. Vi kan bara skicka iteratorn till behållarelementen istället för behållaren själv till STL -algoritmerna.

Iteratordeklaration

Varje behållare i C ++ STL har sin egen iterator. Så vi måste förklara en iterator som:

<type>::iterator it; 

där

• typ: Typ av behållare för vilken iteratorn förklaras.
• det: Namn tilldelat iteratorobjekt.

Vi kan sedan initialisera det genom att tilldela en del giltiga iterator. Om vi ​​redan har en iterator som ska tilldelas vid delningstillfället kan vi hoppa över typdeklarationen med hjälp av bil nyckelord.

auto it = iter 

där iter är iteratorn tilldelad den nyligen skapade ITerator.

Vår C ++ kurs Täcker användningen av iteratorer i STL och säkerställer att du förstår hur du kan korsa olika containertyper.

Exempel på iteratorer

Nedanstående program illustrerar hur man använder iteratorn för att korsa vektorbehållaren:

#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 kanske har märkt att vi har använt Vector :: Begin () och Vector :: End () fungera. Dessa funktioner är medlemsfunktionerna till std :: vektor som returnerar iteratorn till det första och ett element efter det sista elementet i vektorn. Vi använder iterators retur är dessa funktioner för att iterera vektorerna.

Container iteratorfunktioner

C ++ STL tillhandahåller vissa medlemsfunktioner i STL -behållare som returnerar iteratorerna till åtminstone det första och det sista elementet. Dessa medlemsfunktioner definieras i nästan hela STL -behållaren (lämnar några begränsade åtkomstbehållare som stack kö ) med samma namn för konsistens.

Följande tabell visar alla metoder som returnerar iteratorn till containrarna:

Till exempel om en sak är namnet på vektorn då kan vi använda ovanstående metoder som visas nedan:

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

Iteratorsoperationer

Precis som pekararitmetik finns det vissa operationer som är tillåtna på C ++ iteratorer. De används för att tillhandahålla olika funktionaliteter som ökar Iterators betydelse. Det finns 5 giltiga iteratoroperationer i C ++ :

• Avlägsna iteratorer
• Öka/minska iteratorer
• Lägga till/subtrahera heltal till iteratorer
• Subtrahera en annan iterator
• Jämförelse av iteratorer

Avlägsna iteratorer

Dereferencing -drift gör det möjligt för användarna att åtkomst eller uppdatering Värdet på elementet pekas av iteratorn. Vi använder (*) indirektör till dereference iterators precis som pekare.

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

där new_val är det nya värdet som tilldelats det element som pekas av iterator det .

Öka/minska iteratorer

Vi kan öka eller minska iteratorn med 1 med (++) eller (-) operatörer respektive. Ökningsoperation flyttar iteratorn till nästa element i behållaren medan minskningsoperationen flyttar iteratorn till föregående element.

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

Lägga till/subtrahera heltal till iteratorer

Vi kan också lägga till eller subtrahera ett heltal från iteratorerna. Det kommer mer att iteratorn nästa eller tidigare position enligt det extra heltalsvärdet.

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

där int_val är heltalsvärdena som läggs till eller subtraheras från iteratorn det .

Subtrahera en annan iterator

Vi kan subtrahera en iterator från en annan för att hitta avståndet (eller antalet element) mellan minnet de pekar på.

it1 - it2 

Jämförelse av iteratorer

Vi kan också testa de två iteratorerna av samma typ mot varandra för att hitta förhållandet mellan dem. Vi kan använda de relationella operatörerna som (==) jämlikhet och (! =) Ojämlikhetsoperatörer tillsammans med andra relationella operatörer 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 av iteratorer i C ++

STL -iteratorer kan delas ut på grundval av de operationer som kan utföras på dem. Det finns 5 huvudtyper av iteratorer i C ++ som som anges i tabellen nedan tillsammans med stödda containrar och stödda iteratoroperationer.

Som vi kanske har lagt märke till från ovanstående tabell bortsett från inmatnings- och utgångs -iteratorerna När vi går ner i tabellen innehåller iteratortypen funktionerna hos ovan iterator tillsammans med några nya funktioner.

Iteratoradaptrar

Iteratoradaptrar i C ++ är den speciella typen av iteratorer som är byggda över traditionella iteratorer för att tillhandahålla specialiserad funktionalitet. Det finns många iteratoradaptrar i C ++ av vilka några ges nedan:

Iteratorverktygsfunktioner i C ++

C ++ STL tillhandahåller de olika funktionerna för att förenkla arbetet med iteratorer. De är listade i tabellen nedan:

Applikationer av iteratorer med exempel

Iteratorer används i stor utsträckning i C ++ för många olika ändamål medan du arbetar med STL -containrar och algoritmer. Följande är några primära tillämpningar av iteratorer i C ++ som deras kodexempel:

Korsande containrar

Att korsa STL -containrar är den mest grundläggande tillämpningen av iteratorer. I detta använder vi funktioner för början () och slut () för att få start- och slut -iteratorer för att korsa hela behållaren. I grund och botten fortsätter vi att öka början iterator tills den inte är lika med slutet.

Exempel

#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 visas i koden ovan korsar vi setbehållaren. På liknande sätt kan vi använda samma tillvägagångssätt för att korsa alla behållare.

Vänja en behållare

Omvända iteratorer låter dig korsa en behållare från slutet till början utan att behöva manuellt hantera vändningen.

Exempel

#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 

Behållaroberoende algoritmer

Iterators tillåter algoritmer att arbeta med alla funktioner för containertyp som std :: sort () std :: find () och std :: for_each () mer flexibel. Du kan passera iteratorer istället för själva behållaren.

Exempel

#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

Ytterligare tillämpningar av iteratorer

Det finns fler tillämpningar av STL -iteratorer:

• Avståndsberäkning: Att använda std :: avstånd () iteratorer hjälper till att beräkna antalet element mellan två positioner i en behållare.
• Strömma iteration: Strömma iteratorer låter dig behandla inmatnings-/utgångsströmmar som containrar som gör det lättare att läsa från och skriva till strömmar med STL -algoritmer.
• Flytta semantik i STL -algoritmer: Move Iterators introducerar flyttsemantiken i STL -algoritmer som hjälper till att öka prestanda och effektivitet genom att undvika onödig kopiering. Uppgifterna kommer att flyttas enligt reglerna för Move Semantics.
• Anpassade iteratorer för datastrukturer: Anpassade iteratorer kan implementeras för icke-STL-datastrukturer som träd eller grafer för att ge stöd för STL-algoritmer och många andra funktioner. Vi kan behöva följa några uppsättningar av regler och konventioner för att ge korrekt ökning av minskning och andra operationer.