Das Video kommt von YouTube: erst beim Abspielen verbindet sich die Seite mit YouTube (Google).
[TheNilsor] - Informatik - Eigene Liste
Das Wichtigste aus dem Video
Tipp auf eine Zeit – das Video springt genau dorthin.
Transkriptautomatisch erstellt · 268 Zeilen
- hallo Youtube heute wollen wir uns eine eigene Liste anschauen und das soll uns ein bisschen dabei helfen zu verstehen wie ein Container funktioniert und
- eigentlich hatte ich überlegt dass ich ein bisschen so live programmieren mache dann ist mir aber aufgefallen dass das verdammt lange dauern würde ihr werdet
- gleich sehen warum das so lange dauern würde deswegen werden wir heute nur einen kurzen Teil anfangen und dann werden wir mal einen vorgeschriebenen
- teil uns anschauen wir werden uns jetzt eine Liste bauen auf die man nur relativ wenige Funktionen hat das heißt eine Class List werden wir uns
- aufbauen und dann mal gucken wie weit wir damit kommen natürlich wollen wir dass unsere Liste für alle möglichen Typen funktioniert deswegen machen wir
- einen Template hier mit ein type Name type den ich gerne benutze um zu sagen das hier ist ein bestimmter Typ den ich haben will und dann können wir mal
- anfangen uns zu überlegen was eine Liste brauchen könnte und die meisten Listen oder manche Listen oder viele Listen werden programmiert indem man hier nicht
- ein dynamisches Array aufbaut sondern etwas anderes und zwar einzelne Elemente die aufeinander zeigen und ich werde gleich noch sagen
- warum wie sieht das dann aus wenn Elemente aufeinander zeigen na ja wir haben hier ein anfangselement das dann in der Liste irgendwie drin steht wo das
- anfangselement ist und jedes weitere Element hat einen Zeiger auf das nächste Element wenn eine Liste so sogenannt doppelt gebunden ist dann auch auf das
- vorherige Element in diesem Fall bei unserer Liste wird es immer nur das nächste Element sein und dann kann man sozusagen durch die einzelnen Elemente
- durcheren durch die einzelnen Elemente durchgehen indem man dann dieser zeigerspur hier vorne folgt ins erste reingeht dann das nächste dann das
- nächste dann das nächste dann das nächste und so weiter bis man irgendwann auf den Null poointer stößt das ist der Pointer der hier nirgendswoin zeigt das
- ist dann der womit signalisiert wird das ist das letzte Element in jedem einzelnen Element steht dann noch ein Wert drin oder ein value V der hier
- vorne das Element charakterisiert und es hat ein Point auf das nächste Element insgesamt könnte man dann noch sowas machen wie z.B die Gesamtgröße uns
- ausgeben lassen und so weiter das werden wir uns aber gleich erst anschauen in einem anderen Beispiel in unserem Beispiel wird unsere Liste etwas
- einfacher sein und wir benutzen dazu jetzt einfach mal ein Struct anstatt ein eigene Klasse eine innere Klasse könnten wir natürlich auch benutzen ich benutze
- ja mal ein inneres struct das heißt ein Struct aus einem ein Struct das heißt Element und das besitzt generell ein value und zwar vom Typen Typ wir wissen
- ja gar nicht welchen Typ das hat und das heißt es hat ein type V das kann ein in V sein das kann double V sein oder was immer wir dort angesetzt haben und dann
- haben wir zusätzlich zu dem type V noch ein elementpinter auf das nächste Element das heißt hier noch ein Element Pointer der heißt dann next das heißt im
- Typ V elementpinter next sind wir schon ganz gut bedient für unser struct Element und jetzt brauchen wir noch ein Element Pointer first für unsere Liste
- im generellen das heißt das hier ist sozusagen der Anfang der meisten Listen die es gibt warum bauen wir hier nicht einfach irgendein dynamisches Array auf
- wie wir sonst immer gemacht haben na ja das geht natürlich auch das Problem dabei ist dass dynamische AR dann zu reallozieren oder zu vergrößern das ist
- dann wieder eine ganz ganz schwierige Sache ein dynamisches Array was schon aufgebaut ist vergrößern ist eine relativ schwierige Sache deswegen was
- leichter ist ist einfach hier noch ein Element neu dran zu hängen in diesem Fall eine relativ einfache Liste ohne Größe und dann gehen wir mal zum
- Konstruktor über der Konstruktor könnte ungefähr so aussehen natürlich können wir uns da verschiedene Konstruktoren ausdenken ich werde hier aber mal einen
- relativ simpel machen ich werde einfach sagen das erste Element soll gleich Null sein fertig und jetzt will ich natürlich irgendwie die Funktion haben da Glieder
- hinzuzufügen und da gibt es ganz viele Art und Weisen wir werden gleich noch ganz ganz viele Art und Weisen sehen wie man Glieder hinzufügen kann in diesem
- Fall werde ich aber eine ziemlich simple Art und Weise programmieren das heißt ich werde einfach eine Void ad hier vorne machen und die Void ad soll
- irgendwas bestimmtes machen wie addiert sie irgendwas na ja sie braucht erstmal irgendein Typen V hier vorne was dort reingespeichert wird oder ich mach's mal
- damit es nicht zu verwirrend wird mach nenne ich es mal t das heißt das T hier vorne soll in der Liste neu eingespeichert werden dieses Element das
- heißt wir müssen jetzt ein neues Element erstellen mit dem T hier vorne drin und dieses neue Element ist dann ein neues Element unserer Liste so noch mal ein
- bisschen verschoben und was wir jetzt machen wollen ist wir wollen ein neues Element konstruieren und worauf wir aufpassen müssen ist es kann sein dass
- wir hier vorne das erste Element hinzufügen das heißt erstmal müssen wir gucken if first == 0 das heißt wenn wir das erste Element hinzufügen wollen dann
- soll sollen wir hier first gleich new Element aufrufen das heißt dann geben wir auf das erste soll ein neues Element sein und dann können wir sagen na ja vom
- ersten Element wollen wir aber auch irgendwas machen das heißt beim Firsten beim ersten Element das ein Element Pointer das heißt die Dinger aus dem
- Element können wir hier mit dem diesem dererenzierungsoperator hier anfassen und dann sagen wir das das V vom ersten Element soll das T sein was wir uns
- eingegeben haben und dann sagen wir noch möglicherweise dass das nächste Element das next Element soll hier vorne auf Null gesetzt werden denn wir haben h
- gerade das letzte Element eingesetzt oder das erste was ja auch gleichzeitig letzte ist so jetzt das nächste ist die Frage wo geben wir das nächste Element
- überhaupt ein tun wir das vorne oder hinten rein und da werdet ihr gleich sehen dass es da mehrere Möglichkeiten gibt hier vorne werde ich mal die
- implementieren dass wir einfach sagen wir tun das als erstes neues Element rein das heißt hier wenn wir nicht das erste Element wenn das erste Element
- bereits besteht dann wollen wir hier vorne das als neues erstes Element reinfügen das ganze können wir uns mal anschauen das heißt wir haben hier vorne
- einen Pointer auf ein Element und das Element hier hat ein value und ein Pointer auf das nächste Element was dann hier ist so und da
- wollen wir jetzt noch eins dazwischen fügen das heißt was wir machen wollen ist wollen den Pointer hier vorne verändern auf ein neues Element das neue
- Element was wir mit dem neuen value V initialisieren und das neue Element braucht ein Pointer auf das was vorher das erste Element
- war mit seinem V das heißt wir müssen sowohl den Pointer hier vorne auf dieses Element hier vorne speichern als auch müssen wir ein Point
- auf das neue erste Element bringen und das Ganze kann ein bisschen schwierig sein was wir nämlich machen müssen ist müssen nämlich speichern was unser
- erstes Element ist das heißt wir haben jetzt ein Element Pointer das ist das hier den nenne ich ein mal das ist der nächste vom ersten das
- heißt next first ich den einfach mal und der speichert uns jetzt einfach mal das erste Element denn das erste Element wird ja
- gleich das zweite sein oder ich kann ja auch mal schreiben second das wird gleich das zweite sein und was wir dann machen ist wir sagen das erste soll
- jetzt ein neues Element seinement das heißt hier vorne verschieben wir den Zeiger der zuerst
- auf dieses Element gezeigt hat hier vorne auf ein neues Element und was wir dann beim neuen Element machen wollen ist wir wollen sagen der Value den wir
- da haben der soll gleich t sein und das nächste Element von diesem ersten Element was wir da neu erzeugt haben das soll jetzt gleich unser gespeicherter
- wert sein das heißt das alte erste Element das Interessante ist wir müssen hier nicht irgendwie was mit den anderen Elementen machen alle
- anderen Elemente sind noch komplett feine und brauchen gar kein Hilfe da muss man gar nichts machen das war's schon hier vorne das heißt jetzt können
- wir Elemente hinzufügen natürlich können wir das ganze auch kompilieren G+ asd.cpp und Kriegen ein paar Fehlermeldung was soll das denn jetzt na
- ja zum einen hier vorne instruct auch wenn es eine innere Klasse ist muss immer mit dem Punkt abgeschlossen werden aber das ist auch noch nicht alles seht
- ihr nachdem wir dann auch die klasse abgeschlossen haben übersetzt es hier wunderbar das heißt einfach aufpassen hier vorne Semikolon nach der Klasse ist
- immer etwas was man gerne vergisst und das vergesse auch ich sogar noch gerne was wir dann hier machen können ist z.B können eine List aus ins
- entwerfen die nennen wir l und die hier vorne benutzt gerade den Standardkonstruktor das heiß first wird auf Null gesetzt und dann können wir mal
- versuchen l.@4 dazu zu tun und l.@5 dazu zu tun und das können wir einfach mal ausprobieren g++ asd.cpp
- weil wir den Code geändert haben a Exel und zack ja man kann gar nicht sehen ja das ist ein bisschen doof was bräuchten wir denn um irgendwas zu sehen na ja
- vielleicht eine Methode die uns ausgibt was unsere Liste enthält das heißt Void print hier vorne ups das war nicht das was ich wollte so vo print soll uns
- einfach nur das ganze Ding ausgeben und dafür habe ich un schon i Stream inkludiert und den Namespace Standard hier benutzt ganz dre ein Mal generell
- das ganze benutzt so dann schauen wir uns an wie wir durch die Liste hier durchiterieren können das ist unser erster Versuch durch eine Liste
- durchzuerieren und was wir da machen können ist wir können sagen wir haben ein Element Pointer was das momentan Element ist current Element und der soll
- beim ersten Anfang first was er dann macht ist er soll das Element ausgeben jeweils das heißt in diesem Fall werde ich noch
- etwas vorschacheln eine wild Schleife und dann wird er jedes Mal wird einfach sagen C out und dann wird er den Wert davon ausgeben und zwar cur current
- Element und davon will er den Wert haben das istiß current Element Punkt oder dereferenziert als Zeiger V und dann am besten noch entline damit man sieht dass
- ist ein neues Ding und nicht dass noch das alte ist warum habe ich jetzt hier eine weilschleife eingebaut naja wir wollen das ja nicht nur einmal sondern
- so oft wie wir es brauchen in diesem Fall werde ich in die W Schleife reinschreiben das ist Coon Element dass der noch ein dass der nächste davon das
- heißt der Next vom current Element dass der nicht Null ist das heißt wenn der noch einen nächsten hat gibt er das aus und was macht er dann dann geht er zum
- nächsten current Element gleich current Element und next was mache ich hier das werde ich gleich noch sagen zum Schluss will ich noch einmal das current Element
- ausgeben das heißt da kopiere ich mir einfach diese Zeile hier vorne und zack Speicher das ganze dann übersetze ich das ganze asd.cpp a exe übersetzen und
- man sieht noch nichts weil ich die printmethode hier unten noch nicht hingesetzt habe dann sagen wir mal lprint probieren das jetzt mal aus g++
- asdasd.cb a.exe und wir sehen 5 und 4 wird ausgegeben und ich werde gleich noch sagen warum die 5 zuerst ausgegeben wird okay hier vorne der wichtige
- Schritt ist hier vorne die Iteration wie funktioniert diese Iteration na ja was machen wir was machen wir generell wir sagen zuerst einmal wir haben hier
- unsere wunderschöne Liste und ich werde noch mal eine neue Liste aufmalen von nur zwei Elementen damit wir das generell besser verstehen können da ist
- jeweils ein Wert drin und ein Zeiger auf das nächste oder vielleicht machen wir es auch ne mit zwei sollte es eigentlich reichen so und dann haben wir hier noch
- ein first Zeiger der hier drauf zeigt und unser current Element Zeiger geht jetzt zuerst einmal auf den First Zeiger das haben wir hier vorne gesagt current
- Element ist gleich first das heißt wir gehen zum ersten Element hin da starten wir sozusagen was sagt diese weilschleife dann dann sagt die wenn der
- Next Zeiger hiervon nicht der nullzeiger ist der Next Zeiger ist immer der hier BZ der hier das heißt wenn der Next Zeiger da der nullzeiger ist ist das
- selber das letzte Element was machen wir also wenn es nicht das letzte Element ist wenn es nicht das letzte Element ist geben wir
- das Element aus und gehen zum nächsten das heißt wir geben das Element aus hier V wird ausgegeben das mache ich vielleicht mal in pink oder so V wird
- ausgegeben und dann sagen wir unser Zeiger unser current Element Zeiger hier vorne soll der current Element next Zeiger sein das heißt der wird auf den
- next Zeiger gesetzt das heißt was wir da machen ist wir weisen einen Zeiger zu was demententspricht einem Zeiger zu verschieben das heißt wir verschieben
- Zeiger hier dass er diesem weiteren Zeiger hier vorne folgt BZ wir können das auch so einzeichnen wir verschieben den zu dem nächsten Element wenn das
- hier noch ein next Element haben würde würde es auch dort wieder verschoben werden in diesem Fall überprüfen wir wieder mit der Wild Schleife ob das das
- letzte ist in diesem Fall ist es das letzte wie schließen wir das Ganze ab wir geben noch einmal das letzte Element aus denn wir überprüfen ja ob das nicht
- das Letzte ist und in diesem Fall wollen dass es ausgegeben wird wenn es das Letzte ist das heißt hier vorne wenn es nicht das Letzte ist wird es ausgegeben
- und auch wenn es das Letzte ist wird ausgegeben aber nur wenn es nicht das Letzte ist geht man auch weiter das heißt haben wir nicht das letzte Element
- gib aus und geh weiter haben wir das letzte Element gib einfach nur aus und geh nicht weiter dadurch iterieren wir durch
- unsere gesamte elementenliste durch in diesem Fall müssen wir aber darauf aufpassen das hier vorne packt unsere Sachen immer
- vorne vor das heißt zuerst ist unsere Liste einfach nur ein Stück wo unsere vier hier vorne drin steht die wir reintun und dann tun wir noch eine fünf
- dazu die fünf wird aber nicht dahinter getan sondern davor und dann macht es natürlich auch Sinn wenn wir hier vorne haben dass unsere F und dann eine vi
- ausgegeben wird weil wir die Sachen immer davor tun das heißt wenn wir hier noch eine ein davor tun sollte die ein hier vorne zuerst ausgegeben werden und
- natürlich können wir uns auch das angucken das heißt g++ a d.cpp a.exel und dann wird die ein hier vorne vor ausgegeben das ist ja wunderschön jetzt
- brauchen wir eigentlich nur noch eine Funktion um das ganze hier zu löschen weil wir das nicht den Standard Destruktor überlassen wollen das heißt
- ich mache hier auch noch mal eine Void delete hin oder eine Void Pop wird das auch oft genannt und die Void Pop soll nichts anderes machen als das erste
- Element zu löschen natürlich wollen wir dann den Zeiger first auf das nächste Element zeigen lassen das heißt auch hier müssen
- wir wieder das ganze zwischenpeichern das heißt hier vorne bauen wir uns ein Element Pointer next auf und der zeigt jetzt darauf wo das erste hinzeigt das
- heißt unser momentanes erstes Objekt davon nehmen wir den next Zeiger und gucken wo der hinzeigt das Speichern wir uns ein das heißt ich mal das noch mal
- auf wir haben ja ein momentanes Objekt das zeigt auf irgendein anderes Objekt und wir speichern uns jetzt ein wo dieses Objekt hinzeigt das hier ist
- unser first Zeiger der gelbe hier und das blaue speichern wir uns gerade ein denn wenn wir das hier löschen wollen dann wird der blaue unser neuer first
- Zeiger das heißt was wir jetzt noch machen müssen ist dieses Element hier vorne löschen und den First Zeiger verschieben das heißt das machen wir
- jetzt das heißt wir machen jetzt ein delete löschen ein Element und zwar welches Element wollen wir löschen das erste Element was wir hier haben was wir
- danach machen wollen ist aber wollen dass der First Zeiger nicht ein nullzeiger wird sondern wir wollen dass der First Zeiger nun hier hier vorne
- drauf zeigt auf unser nächstes Element das heißt der soll jetzt auf das nächste Element zeigen das heißt indem wir diese Syntax hier vorne benutzen sollte das
- erste Element gelöscht werden das heißt l.pp sollte das erste Element löschen und wir können das durch l.print noch mal überprüfen ob das alles gut gegangen
- ist das heißt g++ asd. C g++ asd.cpp a. Exel und dann sehen wir das ganze wird noch mal ausgegeben mit einer 5 und ein VI die ein hier vorne wurde
- weggepoppt das heißt wir können natürlich auch sowas wie Void erase jetzt erstellen und dort können wir sagen weil das während das noch nicht
- Null ist können wir hier Elemente löschen natürlich haben wir hier noch auf eine Sache nicht aufgepasst was ist wenn das das einzige Element ist und wir
- kein nächstes haben natürlich müssen wir das auch noch mal explizit behandeln das heißt if if first und
- next ich meine natürlich wenn das kein Element ist wenn das hier das wenn das nächste Null ist dann ist das hier Nullpointer dann wird hier das dieses
- Element gelöscht und das first wird auf Nullpointer gelöscht eigentlich genau das was wir haben aber was natürlich überprüfen wollte ist wenn first hier
- vorne schon weg ist das heißt wenn schon alle weg sind dann können wir nirgendswo hier vorne dereferenzieren oder so und was er dann machen soll wenn das erste
- schon Null ist dann brauch er natürlich nichts zu machen natürlich was man hier auch noch wunderschön machen kann ist bei sowas ein Bull zurückgeben und dann
- zurückgeben ob das schon ob wir schon alles gelöscht haben das heißt wenn wir alles gelöscht haben dann return er to und wenn wenn wir noch nicht alles
- gelöscht haben return FS das macht sowas wie die erase Funktion hier vorne sehr sehr viel einfacher das heißt wir können hier einfach schreiben while Pop und
- while nicht Pop natürlich und dann wird er einfach die ganze Zeit poppen bis wir irgendwann hier vorne alles gelöscht haben hier vorne ein true zurückgegeben
- wird und dann sollte die ganze Liste leer sein das können wir ausprobieren mit dem erase hier vorne und dann l.print und hier vorne sollte dann alles
- gelöscht wollen wir das ganze doch ausführen kommt hier eine ssame Fehlermeldung und das ganze funktioniert nicht mehr warum funktioniert es nicht
- mehr ziemlich einfach eigentlich hier vorne die printmethode weiß natürlich nicht dass das ganze Ding leer ist das heißt wir müssen überall wo wir
- irgendwas machen müssen wir überprüfen ob das Ding nicht vielleicht schon leer ist das heißt first le n0 oder wir setzen einen booen fest der sowas
- einspeichert was machen wir wenn das erste schon bereits Null ist das heißt wir nirgendwo einsteigen können eigentlich was machen wir dann na ja
- ziemlich simpel wir müssen da gar nichts ausgeben dann asd.cpp überprüfen noch mal a.xe und dann löscht er sich wieder was ist denn diesmal schief gelaufen was
- ich vergessen habe ist hier vorne diese LS Schleife hier vorne natürlich wollen wir nur das nächste Element löschen wenn das ganze nicht Null ist das heißt hier
- habe ich ein vergessen was ich noch hinzugefügt habe ist hier vorne eine Ausgabe dass sie schon leer ist damit wir sowas vielleicht noch auch
- ausgegeben haben damit da nicht einfach nichts ausgeben wird in diesem Fall sieht das ganze dann folgendermaßen aus ihr seht vielleicht schon ich habe es da
- überprüft Axe und wir sehen 14 dann noch mal die 54 hier vorne weil wir eins gepopt haben dann ausgedrückt haben und dann erasen wir das Ganze und
- drücken es aus wenn wir es erased haben dann ist das Ganze leer und dann drücken wir es aus und da steht dann ist empty oder ist leer das heißt so können wir
- uns eine eigene Liste erstellen und das ganze kann man auch übertreiben so kann man das ganze auch übertreiben ihr seht das habe ich jetzt ein bisschen länger
- programmiert hatte ich ein bisschen Freizeit ihr seht hier vorne include ich ein paar Sachen hier vorne dann habe ich eine eigene Exception class einmal eine
- out of bounce Exception falls ich versuche irgendwas Falsches zu das heißt falls ich versuche etwas anzusprechen was nicht innerhalb meiner
- Liste liegt und eine empty List Exception das heißt wenn ich versuche irgendwas mit einer leeren Liste zu machen was man damit nicht machen darf
- dann hier vorne seht ihr eine ganz normale class List hier vorne die hat eine Größe die merkt sie sich ihre eigene Größe merkt sie sich diese List
- hier vorne einfach nur eine schöne Sache dann gibt es ganz ganz viele verschiedene Funktionen z.B vorne eine get Funktion
- und und zwar von einem in was hier gemacht wird ist wir gehen so lange weiter bis wir hier vorne ähm bis wir hier vorne unser i auf Null
- gesetzt haben das heißt da ist dann z. eine F drin und wir gehen so lange bis zum nächsten Element bis hier vorne i = 0 ist das heißt dann sind wir bei
- hoffentlich beim fünften Element das interessante hier dran ist get hier vorne überprüft selber gar nicht auf den Nullpointer sondern das ist eine private
- Funktion die nur von einer öffentlichen Funktion benutzt wird und die öffentliche Funktion überprüft für diese private Funktion auf den Nullpointer das
- heißt hier vorne das i wird niemals einen Wert haben wo das ganze hier problematisch werden kann weil der Next poointer hier vorne Nullpointer ist und
- wir dann irgendwas versuchen mit dem Nullelement hier vorne zu machen das heißt das kann nicht passieren weil das get hier vorne vorher überprüft wird
- dann auch ein get read das genau das gleiche nur als Konstante Funktion das heißt ein getfunktion hier die nur lesen darf eine get Last Funktion die ein
- genau das gleiche macht wie unsere printfunktion nur dass sie nichts ausgibt sondern nur dann aufhört wenn wir sozusagen das letzte Element
- erreicht haben und dann hört sie einfach dauert auf und gibt das letzte Element aus auch hier wieder die Überprüfung ob das erste Element vielleicht Null ist
- weil wir sonst nicht dereferenzieren dürfen was wir hier vorne drin machen hier vorne da kriegen wir das Element vor dem letzten Element das kann man
- auch machen dann haben wir hier vorne das sind alles übgens noch priv fktion dann eine Funktion die das kleinste Element ausgibt die durchsucht dann das
- ganze Element hier vorne mit jeweils current Element da integriert sie also durch und hat dann auch ein lowest Element Pointer und das lowest Element
- wird zuerst mal auf das erste gesetzt außer wir haben noch ein kleineres wenn wir ein kleineres finden wird das auf dieses kleinere was wir gefunden haben
- gesetzt und das machen wir einfach die ganze Zeit und gucken dann hinter an was das kleinste ist das gleiche noch mal für das he ist dann ein eine vo um eine
- ganze Liste drauf zu tun die hier andere Funktion benutzt die wir gleich noch sehen werden dann ganz ganz ganz viel was ein bisschen komplizierter ist
- Suchalgorithmus den ich euch vielleicht irgendwann später erklären werde und danach hier vorne der normale Konstruktor der normale Destruktor der
- einfach die eras Funktion benutzt die ich voranders geschrieben habe dann ein den ich übrigens auch hier noch mal hätte einbauen sollen das habe ich da
- ein bisschen vermasselt dann haben wir hier noch mal ein eine Liste die hier vorne size GLE 1 gesetzt wird das heißt hier vorne mit
- einem initialelement kann man eine Liste aufbauen man kann eine Liste aufbauen mit einer anderen Liste das heißt das hier vorne ist der copy Konstruktor wie
- ihr euch vielleicht ändern werdet und hier ein Zuweisungsoperator und hier vorne ein Plus gleichoperator auch hier vorne der
- nichts anderes macht als die Sachen drauf zu addieren und dann das hier zu returnen ihr seht hier überall benutzt der Funktion wie oder erase einfach nur
- dafür gemacht dass das Ganze übersichtlicher wird was wir hier machen z.B ist nichts anderes als beim copykonstruktor setzen wir first = 0
- size = 0 und dann tun wir alle hinzu oder fügen wir alle Elemente hinzu was wir hier machen ist wir überprüfen auf selbstzuweisung Löschen unser Array wie
- wir es immer machen setzen die Größen gleich und dann haben wir hier diese vorschleife indem wir alle Daten dazu tun oder
- einfügen wenn ihr euch erinnert das ist eigentlich genau das gleiche was wir auch beim unserer eigenen vektorklasse oder anderen Klassen gemacht haben nur
- halt jetzt in Form von einer Liste anstatt einem dynamischen Array dann hier vorne haben wir dann eine plusgleichoperator der macht nichts
- anderes als zwei Listen zu addieren das ist nicht ganz so interessant dann hier die Funktion atlast die überall benutzt wird was sie macht ist die überprüft
- erstmal ob wir das erste Element haben wenn es das erste Element ist dann tut sie hier vorne tut sie das als neues erstes
- Element rein weil das dann das letzte Element ist das erste ist dann das letzte wenn gar kein Element vorhanden ist und sonst überprüft sie ob sie hier
- ein letztes finden kann wenn wenn sie ein letztes finden kann dann tut sie das hinten dran und sonst wirft sie eine empty List Exception die eigentlich
- theoretisch niemals geworfen werden dürfte weil weil wir immer ein get lastast finden soll
- wenn wir es nicht finden dann muss irgendwas kaputt sein und deswegen wird hier was geworfen dann hier vorne eine add first da wird was zuerst eingesetzt
- das heißt hier wird als erstes Element irgendwas eingesetzt dann after da kann man hinter irgendetwas etwas einsetzen vorne ein Ing si da kann man die Größe
- sich anschauen Pop first kann man das erste löschen Pop Last kann man das letzte löschen Pop an irgendeiner Stelle da kann man das an irgendeiner Stelle
- löschen hier wird auch wieder hier wird auch wieder guckt ob ich das Element an irgendeiner Stelle kriegen kann z.B hier get an einer Stelle und dann wird da
- wieder dieses ganze Zeug gemacht wo man ähm wo ich dann z.B sagen muss ja das das vorherige Element zeigt dann später auf das nächste das heißt das muss mir
- zwischen speichern und so weiter das heißt da gibt's ganz komplizierte Sachen wie man das machen kann aber hier seht ihr dann auch hier kann
- es auch eine out of bounce Exception thrown das passiert wenn der int hier vorne falsch ist das heißt wenn wir ein Element versuchen zu löschen was gar
- nicht in unserem Ding drin ist und dann haben wir so Sachen wie z.B erase da wird das ganze Ding gelöscht das heißt hier vorne poppen wir die
- ganze Zeit das Last weil size größer als Null ist habe ich das hier gemacht natürlich hätte ich hier auch machen können while first leich Null so wie ich
- das vorhin gemacht habe oder ich hätte poplast ein boolean returnen können alles wäre möglich gewesen Phil füllt unser ganzes Ding und dann
- oder löscht das ganze Ding und dann tut es was hinten dran pend tut einfach immer irgendwas hinten dran pend tut was vorne dran pend in tut tut was
- zwischendurch dran dann kann man zwei Sachen addieren man kann eine Liste hier vorne removen also Teile aus einer Liste removen man kann Elemente zählen man
- kann Elemente finden man kann Elemente dereferenzieren man kann Elemente dereferenzieren auf eine sichere Art und Weise die auf jeden Fall überprüft ob
- das Element den überhaupt dereferenziert werden kann und sonst wirft sie eine Exception die man fangen darf kann will dann kann genau das gleiche noch mal nur
- als lesen und zwar diesmal wieder mit konstanten Sachen dann sortieren das ganze hier ist der soltieralgorithmus der relativ schwer ist das Bubble sort
- was oder Quicksort habe ich glaube ich gemacht ja steht sogar da quick sort habe ich genommen dann kann man das höchste das kleinste Element kriegen man
- kann die ausgeben und man kann die mit einer anderen Liste austauschen das heißt sehr sehr sehr sehr sehr viel Funktionalität für unsere kleine Liste
- die ich hier vorne aufgeschrieben habe und wir schauen uns einfach mal an was ich dann damit machen kann und hier vorne habe ich einfach mal ein paar
- Segmente gemacht und wir überprüfen einfach mal ein paar dieser Funktionen das heißt add Last F after und wir schauen uns ein mal an was dann jeweils
- passiert das heißt CLS g++ list.cpp habe ich das drin gespeichert a Exel übrigens was ich hier gemacht habe würde man normalerweise mit einem Header machen
- aber Header haben wir noch nicht besprochen header files deswegen hier ohne Header File äh was wir dann sehen ist hier vorne die Größe wird ausgegeben
- size 4 sozusagen und da warum wird die ausgegeben na ja weil wir hier ein paar Sachen hinzufügen und dann will ich die Größe ausgeben das ist in diesem Fall
- haben wir ein startelement dann haben wir ein letztes Element ein erstes Element und eins ein nachfolgendes Element reingetan in diesem Fall sehen
- wir dann hier vorne die einzelnen Elemente hier vorne die die die wird noch nicht ausgeben aber ih Größe danach wird das letzte
- Element gelöscht das ist dann hier vorne die sech die hier vorne gelöscht wird die alle anderen Elemente werden davor eingesetzt und danach haben wir noch 4
- 35 als Elemente dann wird noch mal das letzte gelöscht dann sehen wir hier vorne ist auch wirklich das Letzte hier vorne wird die fünf das das ste Element
- das wird hier gelöscht machen wir das ganze noch mal noch mal noch mal und was auch ganz interessant ist egal ob wir was was Pop lastast auch noch überprüft
- ist auch ob wir schon fertig sind das heißt wenn die Größe Null ist wie hier vorne und wir noch mal Pop l ausführen ist das alles kein Problem er weiß ich
- habe hier keine Elemente mehr und kann da sozusagen nichts löschen das heißt da ist er ein bisschen vorteilhaft da muss er dann nicht irgendwie eine empt List
- Exception oder so thrown weil er das vorher überprüft was natürlich relativ schlau ist dann können wir hier Sachen hinzufügen als erstes z.B hinzufügen
- dann erste Sachen wieder löschen das ist einfach nur Funktionalität die wir ausprobieren hier vorne fügen wir eine vier zu dann fügen eine dre davor zu und
- dann löschen wir die ersten elementente hier vorne das heißt die dre wird wieder zuerst gelöscht und dann die vier hier vorne auch wieder wird überprüft ob wir
- vielleicht eine Größe von Null haben und was dann noch das letzte add ist ist add after da können wir das an einer bestimmten Stelle einfügen das heißt ihr
- seht dann ihr seht dann hier vorne geben wir die dre ein an der Stelle 0 dann geen wir die 2 ein an der Stelle 0 das heißt immer nach dem
- Element das die 3 ist vor das nullte Element das heißt nach dem Nullen Element was hier die 3 ist geben wir das ein und die ein geen wir nach dem ersten
- Element ein das erste Element ist hier vorne die 2 das heißt nach dem ersten Element nach der Z wird das hier vorne eingegeben wenn wir hier die Werte
- verändern würden würden wir natürlich auch was hier vorne steht verändern in diesem Falle ganz interessant auch noch add after für null wenn noch keins da
- ist muss das das auch überprüfen weil sonst würde es das versuchen das nach dem ersten Element nach dem nullten Element hier vorne einzu legen obwohl
- gar kein nulltes Element da ist das heißt da wird er noch mal explizit überprüft ist meine Liste vielleicht gerade leer und wenn der so ist dann
- wird hier nicht das nullte Element genommen sondern wird einfach das first Element hier vor neu initialisiert was wir dann hier vorne
- machen ist auch ganz interessant wir überprüfen hier unsere Operatoren l von 2++ L Plus+ und L von 2 falls ich mich jetzt richtig erinere hatte ich hier
- sogar mal read Operator eingebaut den ich hier sozusagen auch mal überprüfen könnte nein ich wollte list.cpp machen so da sehen wir jetzt alle drei
- Operatoren l von 2 wenn ich hier vorne vier mache dann stürzt mein Programm einfach ab falls weil meine Liste sozusagen zu klein ist wenn ich hier
- eine vier reinue kriege ich eine out of bounce Exception die ich fangen und damit auch händeln kann wenn ich hier eine vier rein tu dann kriege ich auch
- eine out of bound Exception zurück das heißt add ist der sichere Methode die ein bisschen länger dauert und read ist die sichere Methode die sogar zusätzlich
- noch kanst ist das heißt dort wird der Wert niemals verändert werden das heißt wenn ich hier ein plus plus hinterschreibe wird würde es nicht
- funktionieren was ich dann noch hier zugebaut habe ist das Pop mit einem bestimmten in das heißt hier können wir Werte an verstimmten Stellen poppen das
- heißt in diesem Fall poppen wir zuerst den nullten wert das heißt die drei hier vorne dann poppen wir den ersten von dieser Liste hier unten das ist nicht
- die n die zwei das das wäre h der nullte sondern die ein hier vorne das heißt hier vorne wird diese drei gelöscht und danach löschen wir noch mal die zwei
- hier vorne und das ist sozusagen unser erstes Segment ganz interessant auch Pop hier vorne überprüft ähm überprüft ob wir innerhalb unseres
- Bereiches sind und sonst gibt uns das eine Exception aus ich kann natürlich euch das mal zeigen was dann passiert das heißt ich mache das mal eben wieder
- möglich und dann mache ich ein mal hier eine Exception rein das heißt da sollte jetzt eine
- Exception geworfen werdenchuldigung cppe und wir sehen hier vorne in 1 das war der Wert den wir Abfragen wollten out of bounce
- das ist unsere bounce von unserer momentanen Liste unsere Liste ist ull groß das heißt sie fängt bei Null an und geht bis null das heißt da vorne haben
- wir dann ein out of bounce Exception wenn ich hier wieder Null einfüge geht das ganze wieder das weil Null zwischen 0 und 0 liegt list. CPP a. Exel und das
- ganze funktioniert wieder wunderbar schauen wir uns mal das nächste Segment an das nächste Segment ist das was hier drunter liegt das nächste Segment dort
- haben wir Funktionen wie at first und so weiters Entschuldigung g++ list.cp CPP a.exe und hier haben wir Funktion wie at first erase fill und was
- hier gemacht wird ist z.B wir können hier vorne was vorsetzen wir können hier was löschen wir können hier was auffüllen wir können hier etwas hinten
- dran hängen wir können hier etwas vorne dran hängen wir können hier etwas zwischendurch dran hängen wir können hier Teile löschen die wir uns
- spezialisieren und das ganze sieht dann so aus dass wir dann hier vorne setzen wir ein paar Teile hin dann erasen wir das dann ist die Größe
- Null dann füllen wir das mit vieren und zwar drei Stück dann füllen wir das mit drei und zwar zwei Stück dann tun wir zwei Vieren hinten dran dann setzen wir
- zwei Fünfen vorne dran dann tun wir 3 Nullen hinten dran auf l. get he -1 das ist die Position die ist in diesem Fall das Ende und dann löschen wir die
- letzten die ersten fünf Sachen dann löschen wir zwischen die nächsten vier Sachen hier vorne drei Sachen Entschuldigung und dann löschen wir noch
- mal das Ding hier vorne und das war das zweite Segment seht schon die Segmente werden kürzer das letzte Segment oder das vorletzte ich glaube es ist das
- vorletzte ja es ist das vorletzte da machen wir Sachen mit auch anderen Listen denn hier können wir z.B zwei Listen miteinander swwappen wir können
- die die aufeinander addieren wir können hier vorne den Zuweisungsoperator den entschuldig die kopieroperator
- ausprobieren den plusgleich Operator den zuweisungs Operator und hier vorne das Feind was auch sehr sehr interessant ist die feindfunktion hier vorne ich
- übersetze das noch mal list.cpp a.xe was wir dann hier haben ist erstmal legen wir irgendeine Liste an indem wir hier einfach append benutzen unsere
- schöne append Funktion dann Swen wir ein bisschen rum dann addieren wir aufeinander haben wir vorne z.B Liste 5 22222 das ist weil wir hier vorne Z 5
- zweien addieren auf eine Liste in der SCH einer fün drin ist dann was wir dann hier machen ist wir addieren dann die Liste mit den Einsen auf die Liste mit
- der F und den zweien was wir dann hier machen ist hier weisen wir das Ding selbst zu deswegen passiert da nicht viel hier
- vorne addieren wir noch mal die Einsen drauf und hier vorne finden wir den ersten Wert die erste zwei hier vorne und erhöhen die um ein wenn ich da eine
- ein reintun würde würde dieser Wert erhöht werden wenn ich da eine F reintun würde W der andere Wert erhöht werden ich kann das mal eben zeigen und wie das
- gemacht wird auch hier wieder wir interiieren durch die Liste durch und ihr seht hier vorne da wird die fünf erhöht auf eine Sechs wir iterieren die
- Liste durch und wenn wir einen Wert oder wenn wir den Wert finden geben wir den Wert zurück und dann kann damit gearbeitet werden das heißt auch hier
- wir iterieren wieder durch die Liste nach dem listeninerationssverfahren was ich euch vorhin gezeigt habe und dann vergleichen wir immer die Werte mit
- diesem Vergleichswert den wir hier vorne haben haben dann auch interessant genau das gleiche noch mal nur geben wir dort nicht den verglichenen Wert zurück
- sondern wir erhöhen einfach nur eine Summe die irgendwo anders läuft in diesem Fall gucken wir uns an wie viele zweien hier vorne da sind das sind in
- diesem Fall 5 zien 1 2 3 4 5 zi haben wir auch richtig gezählt das könnten wir auch jetzt für die ein machen oder was auch immer oder für unsere eigenen
- Objekte das hier ist eine Klasse die ist mit einem Template geschrieben worden das heißt sie funktioniert auch für alle Objekte für die die einzelnen
- Operationen dieser Klasse hier vor definiert sind zu guter Letzt dann noch ach nee hier noch eins ach nee was ich hier vorne euch gar nicht gezeigt habe
- das höchste und das kleinste Element können wir uns ausgucken und zwar zwischen zwei bestimmten Reichweiten deswegen haben wir hier zweimal die ein
- vorne und nicht einmal eine ein und eine se dann zusätzlich vorne das letzte wenn wenn es wahr ist dann wir tun ja ein paar Sachen hin und dann sortieren wir
- das Ganze und das benutzt die Quicksort Algorithmus der ist ein bisschen schwieriger aber wir könnten uns das gerne auch angucken oh jetzt habe ich
- ausen das falsche übersetzt list.cpp wollte ich übersetzen a.xe und dann sehen wir hier vorne das ganze Ding wird hier sortiert bevor wir
- das Sortieren ist das ziemlich ungeordnet wie man es hier vielleicht sieht nachdem wir es sortieren ist das Ganze geordnet
- und zwar schön das das ist ein Sortieralgorithmus der funktioniert relativ schön hier vorne habe ich mal gemacht dass er das nicht ausdrücken
- soll wenn ich ihm schreibe dass er das ausdrücken soll das können wir uns jetzt noch als aller aller all aller letztes anschauen was passiert wenn ich das
- ausgebe dann seht ihr auch was dahinter der Kulisse passiert und ihr seht hier schon da passiert eigentlich ganz schön viel der teilt hier immer wieder Sachen
- hier vorne er teilt hier immer wieder Sachen in unterlisten ein hier vorne also bevor es sortiert wird dann teilt der Sachen in eine Liste ein wo weniger
- drin ist eine Liste wo mehr drin ist und dann Arbeit der mit den einzelnen Listen teilt die immer wieder auf in verschiedene Listen und dann irgendwann
- tut er die ganzen Listen zusammen und das hier vorne ist der erste Teil dann macht er es noch mal mit dem zweiten Teil und dann gibt er uns die gesamte
- Liste hier vorne auf das heißt da passiert dann schon ziemlich ziemlich viel es werden immer wieder kleinere Listen erstellt und dann
- hinterer werden die ganzen Listen zusammengepackt ich hoffe mal wirklich dass ich mit euch noch soweit komm dass ich euch auch diesen Algorithmus zeigen
- kann ähm im Programm sieht der suchalgor der der Sortieralgorithmus eigentlich relativ einfach auf der benutzt nur diese drei
- Sachen hier vorne diese drei Zeilen und generell macht er eigentlich nicht viel mehr als überprüfe nach Listen dann äh Teile das in äh unterlisten auf eine
- Liste mit mehr eine Liste mit weniger und dann hinterer tu die Listen in der richtigen Reihenfolge wieder zusammen und das ganze rekursiv und weil es
- rekursiv ist ist das ganze wunderschön wunderschnell und funktioniert auch ziemlich gut das soll's aber fürs heutige Video gewesen sein ich hoffe ihr
- ja euch ich hoffe mal ich hoffe mal euch hat das ganze gefallen ich hoffe mal auch mal wir sehen uns beim nächsten Mal wieder und
- ich hoffe mal ich habe euch jetzt nicht zu Tode gelangweilt wir sehen uns beim nächsten Mal wieder bis dahin wünsche ich euch noch Wunder viel Spaß tschüss