iterators stl
En fullständig översikt över Iteratorer i STL.
I denna handledning kommer vi att undersöka detaljerna om iteratorer, deras typer, fördelar och de olika funktioner de stöder.
mobiltestintervjufrågor och svar för erfarna
Vad är en Iterator? I allmänhet är en iterator precis som alla objekt som pekar på ett visst element i ett dataområde som en matris eller en behållare. En iterator är precis som en pekare i C.
=> Leta efter hela C ++ träningsserien här.
Vad du kommer att lära dig:
- Översikt
- Typer av Iteratorer
- Fördelar med itteratorer
- Iteratorfunktioner
- Slutsats
- Rekommenderad läsning
Översikt
I STL är en iterator ett objekt som kan användas för att korsa eller gå igenom elementen i behållaren med hjälp av en uppsättning operatörer som inkrementoperator (++) eller dereferenceoperator (*).
Iteratorer är avgörande i STL-programmering eftersom de spelar en viktig roll för att ansluta algoritmerna till behållaren förutom att komma åt och manipulera data som lagras i behållarna.
Typer av Iteratorer
Beroende på funktionerna som implementeras av iteratorerna klassificeras de enligt följande:
- Ingångs- och utgångsintervall : Dessa är de mest förenklade typerna av iteratorer. De är mest användbara i sekventiella ingångs- och utmatningsoperationer som innehåller enpass.
- Framåt Iteratorer : Dessa är precis som ingångs iteratorer men har en riktning, dvs framåt riktning i den meningen att de kan användas för att korsa genom ett område i vidarebefordringsriktningen. När framåtriktare inte är konstanta kan de också användas som utgångs iteratorer. De flesta vanliga STL-behållare har åtminstone stöd för framåtriktade iteratorer.
- Dubbelriktade itteratorer : Dessa liknar vidarebefordra iteratorer med den enda skillnaden att de är dubbelriktade. Detta innebär att vi kan använda dessa dubbelriktade iteratorer för att korsa räckvidden framåt och bakåt.
- Iteratorer för slumpmässig åtkomst : Iteratorer med slumpmässig åtkomst är mest kraftfulla bland alla iteratorer. Dessa är icke-sekventiella iteratorer. Slumpmässiga åtkomst iteratorer tillåter oss att komma åt valfritt slumpmässigt värde genom att tillämpa en förskjutning på det aktuella värdet utan att behöva passera genom varje element sekventiellt. De uppvisar liknande egenskaper som Pointers in C.
En sak att notera är att inte alla STL-behållare stöder alla iteratorer. Olika behållare stöder olika iteratorer beroende på kravet på deras funktionalitet.
Nedan är listan över behållare som använder olika iteratorer:
| Behållare | Iteratorer |
|---|---|
| Karta | Dubbelriktad |
| Stack | Ingen iterator |
| Kö | Ingen iterator |
| Prioritetskö | Ingen iterator |
| Lista | Dubbelriktad |
| Vektor | Slumpmässig tillgång |
| och | Slumpmässig tillgång |
| Multikarta | Dubbelriktad |
| Uppsättning | Dubbelriktad |
| Multiset | Dubbelriktad |
Fördelar med itteratorer
Iteratorer är extremt användbara, särskilt vid programmering med olika intervall och behållare.
Några av fördelarna med att använda iteratorer vid programmering kan sammanfattas nedan:
# 1) Kodåteranvändbarhet
Så länge vi använder iteratorer för att komma åt element i vårt program, kan vi bara ändra namnet på behållaren i vår iteratordefinition och använda resten av koden på ett liknande sätt när vi behöver ändra behållaren.
Detta är särskilt användbart i scenarier där vi planerar att ersätta en vektorbehållare med en listbehållare. Om vi använde () -operatören istället för iteratorer skulle koden för åtkomstelement vara värdelös när vi byter behållare.
# 2) Enkelhet och bekvämlighet med programmering
Iteratorer har olika inbyggda funktioner som hjälper oss att korsa och komma åt innehållet i containern enkelt och bekvämt.
Till exempel , vi behöver inte fortsätta kontrollera slutet på listan eller arrayliknande vi måste göra när vi använder () -operatörer och vi behöver ändra programkoden som när vi vill lägga till element, och vi måste ändra dem för en loop .
När vi använder iteratorer kan vi direkt komma åt start- () och slut () -funktionerna för iteratorerna utan att behöva hålla en flik på när vi når slutet av listan och vi behöver inte ändra dem för en loop.
# 3) Dynamisk lägg till / ta bort
När vi använder iteratorer kan vi enkelt och dynamiskt lägga till eller ta bort elementen i behållaren utan att behöva flytta elementen som vi måste göra i () -operatörer.
Låt oss demonstrera detta med följande exempel:
#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:
Vektorinnehåll efter tillsats
3 1 1 2
Vektorinnehåll efter radering
3 1 2
Som vi ser i exemplet ovan ser vi att med hjälp av iteratorer kan vi enkelt lägga till eller ta bort element från en behållare (vektor i detta fall), utan att behöva tillgripa den komplexa programmeringen av skiftande element och omstrukturera behållaren.
Iteratorfunktioner
Eftersom iteratorer i sig är inbyggda konstruktioner stöder de olika operationer som kan göras på iteratorobjekt. Dessa operationer / funktioner gör det möjligt för oss att effektivt korsa området och även manipulera elementen inuti containern.
Nu kommer vi att se några större operationer som iteratorer stöder.
- Börja: Returnerar iteratorns första eller startposition.
- slutet: Returnerar iteratorns sista position eller 'efter slut' position.
- föregående: Returnerar den nya iteratorn efter att ha minskat antalet positioner som ges i argumentet.
- Nästa: Returnerar ny iterator efter att ha flyttat fram eller ökat antalet positioner som ges i argumentet.
- inläggare: Infogar element vid valfri position i en behållare.
- förskott: Ökar iteratorpositionen till det angivna numret i argumentet.
Vi kommer att demonstrera användningen av en del av denna funktion / operation i följande 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:
Med nästa () är den nya itatorn på: 2
Positionen för ny iterator som använder prev () är: 3
Efter förskottet är itr1 placerat på: 3
Med hjälp av ovanstående program har vi demonstrerat användningen av olika iteratoroperationer.
Slutsats
Således har vi kommit till slutet av denna handledning om Iterators.
Hittills har vi diskuterat grunderna för STL, från nästa handledning kommer vi att börja med STL-behållare och deras programmering.
=> Kontrollera Komplett C ++ GRATIS träningsserie här.
Rekommenderad läsning