lists stl
Lær alt om lister i STL at kende sammen med dens implementering.
Lister er sekventielle beholdere. Lister indeholder elementer i ikke-sammenhængende placeringer. Vi har diskuteret arrays og vektorer i vores tidligere tutorials.
I tilfælde af array- og vektorcontainere, da disse containere lagrer data i sammenhængende hukommelse, viser indsættelsesoperation midt i disse containere at være meget dyrt, da vi er nødt til at skifte de eksisterende elementer i overensstemmelse hermed for at give plads til det nye element.
=> Se her for at udforske den komplette C ++ tutorials-liste.
hvad er testplan i qa
Hvad du lærer:
Oversigt
Listen er en container, der overvinder denne ulempe ved array- og vektorcontainere. Det giver os mulighed for at indsætte elementer hvor som helst på listen uden at forårsage meget overhead. Men lister er langsommere end vektorer for så vidt angår gennemkørsel.
I denne vejledning vil vi se implementeringen af lister i STL sammen med de forskellige operationer af traversal, manipulationer og adgang til listen med eksempler.
Bemærk, at et flertal af listehandlinger ligner dem hos vektorer, og derfor vil læsere, der allerede har læst vores vejledning om vektorer, ikke have problemer med at fortolke listebegreber.
Erklæring og initialisering
For at implementere listebeholder og bruge alle dens fordele skal vi medtage en headerfil i vores program.
#include Den generelle erklæring for listebeholder er
std::list listName; For eksempel,Vi kan erklære en liste med navnet 'min liste' af typen int på følgende måde:
std::list mylist; Vi kan også initialisere listen på erklæringstidspunktet eller tilføje elementer til den ved hjælp af en af de operationer, den understøtter.
Lad os se, hvordan vi kan initialisere listen, vi oprettede ovenfor.
std::list mylist = {1, 1, 2, 3, 5}; Ovenstående initialisering vil blive lagt i hukommelsen som vist nedenfor:
Når vi først har initialiseret listen, kan vi få adgang til elementerne på en liste ved hjælp af en iterator. Iteratorfunktionerne 'begynder' og 'slutter' hjælper os med at krydse listenelementerne.
Bemærk: Iterator til listen understøtter også andre iteratorer som reverse iteratorer (rbegin, rend), konstante iteratorer (cbegin, cend) og konstant reverse iterators (crbegin, rend) og kan bruges på en lignende måde som vektorer.
Følgende eksempel viser dette.
#include #include #include #include using namespace std; int main() { list mylist = {1, 1, 2, 3, 5}; cout<<”List elements are: “; list::iterator it; for(it=mylist.begin();it!=mylist.end();++it) cout<<*it<<” “; }Produktion:
Listeelementer er: 1 1 2 3 5
Således har vi i ovenstående eksempel erklæret en liste over Fibonacci-sekvensen. Dernæst erklærer vi en iterator af samme type som listen, og derefter bruger vi til loop, og vi udskriver listeindholdet fra start til slut.
Lad os nu springe til de operationer eller funktioner, som container i STL giver os.
Listeoperationer
- Indsæt: Bruges til at indsætte et element i den givne position. Returnerer en iterator, der peger på det første indsatte element.
indsæt (pos, num_elem, elem)
Hvor,
pos => Position, hvor nye elementer skal indsættes.
num_elem => Antal elementer, der skal indsættes er som standard 1.
vare => Faktisk værdi, der skal indsættes.
Lad os forstå indsætningsfunktionen ved at tage et eksempel.
#include #include // for list operations using namespace std; int main() { list mylist = {1,1,2}; list::iterator it = mylist.begin(); // iterator to point to 4th position advance(it,` 3); // inserts 3 at 4th position mylist.insert(it, 3); cout << 'The list after inserting' << ' 1 element using insert() is : '; for (list::iterator i = mylist.begin();i != mylist.end();i++) cout << *i << ' '; cout << endl; }Produktion:
Listen efter indsættelse af 1 element ved hjælp af insert () er: 1 1 2 3
Dette er et eksempel på kun at indsætte et element ved 4thposition på listen, som til sidst er den sidste position. Derfor har vi først en liste, som vi har defineret iteratoren til, der peger på begyndelsen af listen. Derefter skifter vi denne iterator til 4thposition, og kald derefter indsæt for at indsætte 1 element.
Vi kan også indsætte mere end et element ved at angive den anden parameter i indsætningsfunktionen. Når det ikke er angivet, er det som standard 1.
- skub tilbage :Tilføjer et nyt element i slutningen af listen.
- push_front :Tilføjer et nyt element i begyndelsen af listen.
Lad os se et eksempel, der demonstrerer brugen af push_back og push_front-funktioner.
#include #include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3}; cout<<'List elements are: '; printlist(mylist); mylist.push_front(0); mylist.push_back(5); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produktion:
Listeelementer er: 1 1 2 3
Listeindhold efter push_front og push_back: 0 1 1 2 3 5
I dette eksempel opretter og lister vi først alle to elementer til det, et hver foran og bagpå ved hjælp af henholdsvis push_front og push_back-funktioner. Outputtet viser den ændrede liste, efter at begge funktioner er udført.
- pop_back :Fjerner det sidste element på listen og derved krymper listen med 1.
- pop_front :Fjerner det første element på listen og derved krymper listen med 1.
Følgende eksempel viser brugen af pop_back og pop_front-operationer på listen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); mylist.pop_front(); mylist.pop_back(); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }Produktion:
Listeelementer er: 1 1 2 3 5
Listeindhold efter push_front og push_back: 1 2 3
Som beskrevet i operationens definition fjerner hver af operationerne pop_front og pop_back elementet fra front og bagside af listen, dvs. henholdsvis det første og det sidste element på listen og dermed hver gang det reducerer størrelsen på listen med 1.
- størrelse :Returnerer størrelsen på listen, dvs. antallet af elementer på listen.
- tom :Kontrollerer, om listen er tom.
- slette :Fjerner et element eller et række elementer fra listen.
- klar :Fjerner alle elementerne fra listen ved at gøre den til størrelse 0.
Nedenfor er et eksempel for at demonstrere brugen af alle ovennævnte funktioner, dvs. størrelse, tom, slet og ryd.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'size of the list: '< Produktion:
Listeelementer er: 1 1 2 3 5
listeens størrelse: 5
Liste efter sletning af første element: 1 2 3 5
Ny størrelse på listen: 4
listeens størrelse efter klar: 0
Ovenstående program viser alle de fire funktioner, der er relateret til listen kapacitet. Vi ser, at listestørrelsen falder med 1, når vi sletter 1 element på listen. Mens vi kalder en klar operation på listen, er størrelsen 0, hvilket betyder, at alle elementerne på listen fjernes.
- foran :Returnerer værdien af det første element på listen.
- tilbage :Returnerer værdien af det sidste element på listen.
- bytte rundt :Byt indholdet af en liste med indholdet af en anden liste af samme størrelse og type.
- baglæns :En algoritme, der vender listen.
- sortere :Sorterer den givne liste.
Nedenstående eksempel viser brugen af front-, bagside-, reverse-, sorterings- og swap-funktionerne.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'
Front of the list: '< Produktion:
Listeelementer er: 1 1 2 3 5
Forrest på listen: 1
Bagsiden af listen: 5
Omvendt liste: 5 3 2 1 1
Indholdet af ulige liste: 1 3 5 7 9
Efter bytte
min liste: 1 3 5 7 9
Oddliste: 5 3 2 1 1
I denne kode udskriver vi først for- og bagværdierne på listen mylist. Derefter vendes denne liste, og den omvendte liste udskrives. Derefter definerer vi endnu en liste over ulige numre, som ikke er i nogen rækkefølge, og vi kalder 'Sort' algoritmen for at sortere denne liste. Derefter bytter vi de to lister ved hjælp af swap-funktionen og udskriver de udvekslede lister.
- splejsning :Denne funktion bruges til at overføre indholdet af en liste til en anden liste på en bestemt position.
Begge lister skal være af samme type.
splejsning (position, liste);
hvor,
position => Position, hvor listeindholdet skal overføres.
liste => Liste, hvis elementer skal overføres.
Eksemplet nedenfor viser brugen af splejsningsfunktionen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 8,13}; cout<<'List elements are: '; printlist(mylist); list seclist = {2,3,5}; cout<<'list to be spliced: '; printlist(seclist); list:: iterator it = mylist.begin(); it ++; it++; mylist.splice(it,seclist); cout<<'
List contents after splicing at position 2: '; printlist(mylist); } Produktion:
Listeelementer er: 1 1 8 13
liste, der skal splejses: 2 3 5
Liste over indhold efter splejsning i position 2: 1 1 2 3 5 8 13
Det eksempel viser, at vi bruger to lister. Først flyttes iteratoren for min liste til to positioner, og derefter kaldes splejsningsfunktionen for at overføre indholdet af den anden liste til den tredje position på den første liste.
- gå :I modsætning til splejsningsfunktion, der kan bruges til at overføre indholdet af en liste til en anden på en bestemt position, flettes operation sammen direkte to lister for at danne en enkelt liste. For fletning skal begge lister være i sorteret rækkefølge.
Nedenfor er et eksempel på at demonstrere fletningsfunktionen.
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1,2,3,5,8}; list seclist = {4,6,7}; cout<<'First List: '; printlist(mylist); cout< Produktion:
Første liste: 11 2 3 5 8
Anden liste: 4 6 7
Listeindhold efter fletning af to lister:
1 1 2 3 4 5 6 7 8
Således i ovenstående program har vi to lister, der er sorteret. Vi kalder sammenfletning på disse to lister. Den resulterende liste er en sorteret liste, der indeholder elementerne i begge lister.
åbning af en xml-fil i Excel
Konklusion
Vi er kommet til slutningen af denne tutorial om Lister i STL. Vi håber, at denne vejledning ville have givet dig enorm viden om Lister i STL.
=> Tjek her for at se AZ af C ++ træningsvejledninger her.
Anbefalet læsning