iterators stl
En komplet oversigt over Iteratorer i STL.
I denne vejledning vil vi se på detaljerne i iteratorer, deres typer, fordele og de forskellige funktioner, de understøtter.
hvordan man initialiserer et generisk array i java
Hvad er en Iterator? Generelt er en iterator ligesom ethvert objekt, der peger på et bestemt element i en række data som et array eller en container. En iterator er ligesom en markør i C.
=> Se efter hele C ++ træningsserien her.
Hvad du lærer:
- Oversigt
- Typer af Iteratorer
- Fordele ved ikteratorer
- Iteratorfunktioner
- Konklusion
- Anbefalet læsning
Oversigt
I STL er en iterator et objekt, der kan bruges til at krydse gennem eller gå gennem elementerne i beholderen ved hjælp af et sæt operatorer som inkrement operator (++) eller dereference operator (*).
Iteratorer er afgørende i STL-programmering, da de spiller en vigtig rolle i at forbinde algoritmerne til containeren ud over at få adgang til og manipulere de data, der er gemt inde i containerne.
Typer af Iteratorer
Afhængig af funktionaliteten implementeret af iteratorerne klassificeres de som følger:
- Input og output Iteratorer : Dette er de mest forenklede typer iteratorer. De er mest nyttige i sekventielle input-output-operationer, der indeholder single-pass.
- Fremadrettere : Disse er ligesom input-iteratorer, men har en retning, dvs. fremadretning i den forstand, at de kan bruges til at krydse et område i videresendingsretningen. Når frem iteratorer ikke er konstante, kan de også bruges som output iteratorer. De fleste standard STL-containere understøtter i det mindste forward iteratorer.
- Tovejs rystere : Disse ligner forward iteratorer med den eneste forskel, at de er tovejs. Dette betyder, at vi kan bruge disse tovejs iteratorer til at krydse området gennem både fremad og bagud.
- Tilfældige adgangsteratorer : Iteratorer med tilfældig adgang er mest magtfulde blandt alle iteratorerne. Disse er ikke-sekventielle iteratorer. Tilfældig adgang iteratorer giver os adgang til enhver tilfældig værdi ved at anvende en forskydning til den aktuelle værdi uden at skulle passere gennem hvert element i rækkefølge. De udviser lignende egenskaber som pointer i C.
En ting at bemærke er, at ikke alle STL-containere understøtter alle iteratorerne. Forskellige containere understøtter forskellige iteratorer afhængigt af kravet om deres funktionalitet.
Nedenfor er listen over containere, der bruger forskellige iteratorer:
| Beholdere | Iteratorer |
|---|---|
| Kort | Tovejs |
| Stak | Ingen iterator |
| Kø | Ingen iterator |
| Prioritetskø | Ingen iterator |
| Liste | Tovejs |
| Vektor | Tilfældig adgang |
| og | Tilfældig adgang |
| Multimap | Tovejs |
| Sæt | Tovejs |
| Multisæt | Tovejs |
Fordele ved ikteratorer
Iteratorer er yderst nyttige, især når de programmerer med forskellige intervaller og containere.
Nogle af fordelene ved at bruge iteratorer til programmering kan opsummeres nedenfor:
# 1) Genanvendelighed af kode
Så længe vi bruger iteratorer til at få adgang til elementer i vores program, kan vi bare ændre navnet på containeren i vores iterator-definition og bruge resten af koden på en lignende måde, når vi har brug for at ændre containeren.
Dette er især nyttigt i scenarier, hvor vi planlægger at udskifte en vektorbeholder ved hjælp af en listebeholder. Hvis vi i stedet for iteratorer brugte () -operatøren, ville koden for at få adgang til elementer være ubrugelig, når vi skiftede containere.
# 2) Nem og bekvem programmering
Iteratorer leveres med forskellige indbyggede funktioner, der hjælper os med at krydse og få adgang til indholdet af containeren let og bekvemt.
For eksempel , vi behøver ikke fortsætte med at kontrollere slutningen af listen eller det array-lignende, vi skal gøre, mens vi bruger () -operatorer, og vi skal ændre programkoden som når vi vil tilføje elementer, og vi skal ændre dem for en loop .
Når du bruger iteratorer, kan vi få direkte adgang til start () og slut () -funktionerne for iteratorerne uden at beholde en fane, når vi når slutningen af listen, og vi behøver heller ikke ændre dem til en loop.
# 3) Dynamisk tilføj / fjern
Når vi bruger iteratorer, kan vi nemt og dynamisk tilføje eller fjerne elementerne i containeren uden at skulle flytte elementerne, som vi skal gøre i () -operatører.
Lad os 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< Produktion:
Vektorindhold efter tilføjelse
3 1 1 2
Vektorindhold efter sletning
3 1 2
Som det ses i ovenstående eksempel ser vi, at ved hjælp af iteratorer kan vi let tilføje eller fjerne elementer fra en container (vektor i dette tilfælde) uden at skulle ty til den komplekse programmering af skiftende elementer og omstrukturering af containeren.
Iteratorfunktioner
Da iteratorer i sig selv er indbyggede konstruktioner, understøtter de forskellige operationer, der kan udføres på iteratorobjekter. Disse operationer / funktioner giver os mulighed for effektivt at krydse området og også manipulere elementerne inde i containeren.
Nu vil vi se et par større operationer, som iteratorer understøtter.
- begynde: Returnerer iteratorens første eller startposition.
- ende: Returnerer iteratorens sidste position eller 'efter slut' position.
- forrige: Returnerer den nye iterator efter at have reduceret antallet af positioner angivet i argumentet.
- Næste: Returnerer ny iterator efter fremskridt eller stigning i antallet af positioner angivet i argumentet.
- indsætter: Indsætter element i en vilkårlig position i en container.
- rykke: Forøger iteratorpositionen til det angivne nummer, der er angivet i argumentet.
Vi vil demonstrere brugen af noget af denne funktion / operation 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; } Produktion:
Ved hjælp af næste () er den nye iterator ved: 2
Positionen for ny iterator ved hjælp af prev () er: 3
Efter forhåndsoperationen er itr1 placeret ved: 3
Ved hjælp af ovenstående program har vi demonstreret brugen af forskellige iteratorhandlinger.
Konklusion
Således er vi kommet til slutningen af denne tutorial om Iterators.
Indtil videre har vi diskuteret det grundlæggende i STL, fra vores næste tutorial og fremefter vil vi begynde med STL-containere og deres programmering.
=> Tjek Komplet C ++ GRATIS træningsserie her.
Anbefalet læsning