Egy  iterátor c ++ -ban  egy mutatószerű objektum, amely az STL-tartály egyik elemére mutat. Általában az STL -tartály tartalmának áthurlására használják a C ++ -ban. Az STL iterátorok fő előnye, hogy az STL algoritmusokat függetlenné teszik a használt konténer típusától. Az iterátort csak a konténer helyett átadhatjuk a konténer elemeknek az STL algoritmusokhoz.

Iterátor nyilatkozat

A C ++ STL minden tartályának megvan a saját iterátora. Tehát az iterátort úgy kell kijelölnünk, hogy:

<type>::iterator it; 

ahol

• Típus: A konténer típusa, amelyre az iterátort deklarálják.
• azt: Az iterator objektumhoz rendelt név.

Ezután inicializálhatjuk egy érvényes iterátor hozzárendelésével. Ha már van egy iterátorunk, amelyet a Delcaration idején kell kiosztani, akkor a típusnyilatkozatot kihagyhatjuk a autó Kulcsszó.

auto it = iter 

ahol iter az újonnan létrehozott IT iteratorhoz rendelt iterátor.

A miénk C ++ tanfolyam Fedezi az iterátorok használatát az STL -ben, biztosítva, hogy megértse, hogyan kell átjutni a különböző konténertípusokhoz.

Példa az iterátorokra

Az alábbi program azt szemlélteti, hogyan lehet az iterátort használni a vektor tartály áthaladására:

#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 

Mint talán észrevetted, használtuk Vektor :: Begin () és Vector :: End () funkció. Ezek a funkciók az STD :: vektor tagfunkciói, amelyek az iterátort az első és egy elemre adják vissza a vektor utolsó eleme után. Az iterátorok visszatérését használjuk, ezeknek a funkcióknak a vektorok iterálásához.

Konténer iterátor funkciók

A C ++ STL néhány tagfunkciót biztosít STL konténer Ez visszatér az iterátorokhoz legalább az első és az utolsó elemhez. Ezeket a tagfunkciókat szinte az összes STL -tartályban definiálják (hagyva néhány korlátozott hozzáférési tartályt, mint például halom sor ) Ugyanazzal a névvel a konzisztencia érdekében.

Az alábbi táblázat felsorolja az összes olyan módszert, amely az iterátort visszaadja a konténerekbe:

Például, ha egy dolog a vektor neve, akkor a fenti módszereket az alábbiak szerint használhatjuk:

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

Iterátorok műveletei

Csakúgy, mint a mutató aritmetika, vannak olyan műveletek, amelyek megengedettek a C ++ iterátorokon. Olyan funkciók biztosítására szolgálnak, amelyek növelik az iterátorok fontosságát. 5 érvényes van iterator műveletek C ++ -ban :

• Dereferencia iterátorok
• Az iterátorok növelése/csökkentése
• Az egész szám hozzáadása/kivonása az iterátorokhoz
• Egy másik iterátor kivonása
• Az iterátorok összehasonlítása

Dereferencia iterátorok

A Dereferencing művelet lehetővé teszi a felhasználók számára hozzáférés vagy frissítés Az iterátor által mutatott elem értéke. A (*) indirekációs operátor A Dereference iterátorokhoz, akárcsak a mutatók.

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

ahol New_val az iterátor által mutatott elemhez rendelt új érték azt -

Az iterátorok növelése/csökkentése

Az iterátort 1 -vel növelhetjük vagy csökkenthetjük (++) vagy (-) operátorok illetőleg. A növekedés művelete az iterátort a tartály következő elemére mozgatja, míg a csökkentési művelet az iterátort az előző elemre mozgatja.

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

Az egész szám hozzáadása/kivonása az iterátorokhoz

Felvehetünk vagy kivonhatunk egy egész értéket az iterátorokból. Ez inkább az iterátort a következő vagy az előző pozícióhoz a hozzáadott egész értéknek megfelelően fogja elérni.

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

ahol int_val az egész értékek, amelyeket hozzáadnak vagy kivonnak az iterátorból azt -

Egy másik iterátor kivonása

Kivonhatjuk az egyik iterátort a másikból, hogy megtaláljuk a távolságot (vagy az elemek számát) a memória között.

it1 - it2 

Az iterátorok összehasonlítása

Megpróbálhatjuk az azonos típusú két iterátort egymással szemben, hogy megtaláljuk a kapcsolatot közöttük. Használhatjuk azokat a relációs operátorokat, mint a (==) egyenlőség és (! =) Egyenlőtlenség -operátorok, valamint más relációs operátorok, például< > <= >=.

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 

Az iterátorok típusai C ++ -ban

Az STL iterátorok feloszthatók a rajtuk végrehajtható műveletek alapján. A C ++ -ban 5 fő iterátor létezik, amelyek az alábbi táblázatban felsoroltak, a támogatott konténerekkel és a támogatott iterátor műveletekkel együtt.

Mint a fenti táblázatból észrevettük, a bemeneti és a kimeneti iterátoroktól eltekintve Amint lemenünk az asztalon, az iterátor típus a fenti iterátor tulajdonságait, valamint néhány új funkciót tartalmaz.

Iterátor adapterek

Az iterator adapterek a C ++ -ban a speciális iterátorok típusa, amelyet a hagyományos iterátorok fölé építettek, hogy speciális funkcionalitást biztosítsanak. A C ++ -ban sok iterator adapter található, amelyek közül néhányat az alábbiakban találunk:

Iterator hasznossági funkciók a C ++ -ban

A C ++ STL biztosítja a különféle funkciót az iterátorokkal való munka egyszerűsítéséhez. Az alábbi táblázatban vannak felsorolva:

Iterátorok alkalmazása példákkal

Az iterátorokat széles körben használják a C ++ -ban, sokféle célra, miközben az STL konténerekkel és algoritmusokkal dolgoznak. Az alábbiakban bemutatjuk az iterátorok néhány elsődleges alkalmazását a C ++ -ban, amelyek kódpéldák:

Tartályok átjárása

Az STL konténerek áthaladása az iterátorok legalapvetőbb alkalmazása. Ebben a Begin () és a End () funkciókat használjuk a kezdet és a vége iterátorok eléréséhez, hogy áthaladjanak az egész tartályon. Alapvetően folyamatosan növeljük a Begin iteratort, amíg az nem egyenlő a végével.

Példa

#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 

Amint a fenti kódban látható, áthaladunk a beállított tárolón. Hasonlóképpen ugyanazt a megközelítést alkalmazhatjuk bármilyen tartály áthaladására.

A konténer megfordítása

A fordított iterátorok lehetővé teszik, hogy a tartályt a végétől a kezdetéig áthaladjanak anélkül, hogy a visszafordítás kézi kezelésére lenne szükség.

Példa

#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 

Konténerfüggetlen algoritmusok

Az iterátorok lehetővé teszik az algoritmusok számára, hogy bármilyen konténer típusú funkciókkal működjenek, mint például az STD :: sort () STD :: find () és az STD :: for_each () rugalmasabb. A tényleges konténer helyett átadhatja az iterátorokat.

Példa

#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

Az iterátorok kiegészítő alkalmazásai

Több alkalmazást alkalmaznak az STL iterátorok:

• Távolsági kiszámítás: Az STD :: Respice () iterátorok használata segít kiszámítani az elemek számát a konténer két pozíciója között.
• Patak iteráció: A patak iterátorok lehetővé teszik a bemeneti/kimeneti adatfolyamok, például a konténerek kezelését, így az STL algoritmusok segítségével megkönnyítik az olvasást és a streamek írását.
• Mozgassa a szemantikát az STL algoritmusokban: A MOVE iterators bemutatja a MOVE szemantikát az STL algoritmusokban, amelyek elősegítik a teljesítmény és a hatékonyság növelését azáltal, hogy elkerülik a felesleges másolást. Az adatokat a mozgási szemantika szabályai szerint továbbítják.
• Egyedi iterátorok az adatszerkezetekhez: Az egyéni iterátorok olyan nem-STL adatszerkezetekhez valósíthatók meg, mint a fák vagy grafikonok, hogy támogassák az STL algoritmusokat és sok más funkciót. Lehet, hogy be kell tartanunk néhány szabályt és konvenciót, hogy a csökkentés és más műveletek megfelelő növekedése érdekében biztosítsuk.