OOP Fifo mit linearer zykl Liste und folgenden Auflagen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • OOP Fifo mit linearer zykl Liste und folgenden Auflagen

    Hallo Leute,

    studiere Elektrotechnik im 4ten Sem. und hab schon n' paar fifos/lifos
    in C/C++ programmiert.
    Diese arbeiten entweder auf simplen arrays,
    oder dynamischen Feldern, oder auch wie hier verlangt, auf einfach verketteten Listen.

    Heute kam ne verwirrte 2Sem. Studentin zu mir und legte mir folgende Aufgabenstellung aus Prog für E-Techniker vor:


    "In dieser Aufgabe soll eine Warteschlange (FIFO) für Integer-Werte entworfen
    und implementiert werden. Die Warteschlage soll beliebig viele Integer-Werte
    aufnehmen können. Die Warteschlange soll basierend auf einer Zyklischen Liste
    arbeiten.

    Implementieren Sie zuerst eine Klasse ListenElem, mit folgenden Eigenschaften
    und Methoden:

    • Die private Eigenschaft value speichert den Integer-Wert
    • Die private Eigenschaft pNext enthält den Zeiger zum nächsten ListenElem.
    • Ein Default-Konstruktor soll alle Eigenschaften sinnvoll initialisieren
    • Die Methoden setValue() und getValue() dienen zum Schreiben und Lesen
    des Integer-Wertes

    • Die Methoden setNext() und getNext() dienen zum Lesen und Schreiben des
    Zeigers auf das nächste ListElem


    Auf dieser Klasse aufbauend implementieren Sie dann Ihre Warteschlange. Ihre
    Warteschlange soll folgende Eigenschaften und Methoden besitzen:

    • Die private Eigenschaft pTop speichert einen Zeiger auf das nächste freie
    ListElem.

    • Die private Eigenschaft pBottom speichert einen Zeiger auf das älteste
    belegte LiestElem.

    • Einen Konstruktor, der optional die Größe der Warteschlange übergeben
    bekommt. Als minimaler Wert wird die Größe 1 akzeptiert. Wird keine
    Größe angegeben, wird eine Warteschlange mit 4 Elementen angelegt.

    • Überlegen Sie sich, ob Sie einen Destruktor und eine Copy-Konstruktor
    benötigen.

    • Eine private Methode extend(), die Ihre Warteschlange um ein weiteres
    ListenElem erweitert.

    • Die Methode push(), um einen Int-Wert in die Warteschlange
    einzufügen.

    • Die Methode pop(), um den ältesten gespeicherten Wert zurückzugeben.

    Intern soll Ihre Warteschlange folgendermaßen funktionieren:

    Konstruktor

    Im Konstruktor wird eine zyklische Liste aufgebaut, in der das letzte
    Listenelement wieder auf das erste Listenelement verweist. Gehen Sie hierbei
    folgendermaßen vor:

    1. Erzeugen Sie ein erstes ListElem (als Liste der Größe 1)

    2. Nutzen Sie die Methode extend() um weitere Elemente zu erzeugen
    pTop zeigt zu Beginn auf ein beliebiges Element in der Liste. pBottom besitzt
    den Wert NULL, da ja noch kein Element eingefügt wurde.


    push()

    Die Warteschlage soll immer mindestens Platz für ein weiteres Element
    besitzen. So kann immer in dem ListenElem, auf das pTop verweist, der Wert
    abgespeichert werden. Dann muss überprüft werden, ob die Schlange voll belegt
    ist: in diesem Fall enthält der Nachfolger von pTop denselben Zeiger wie
    pBottom. Um dann wieder ein neues Listenelemt einzufügen muß extend()
    aufgerufen werden. Weiterhin muss überprüft werden, ob mit diesem push() das
    erste Element in die Warteschlange eingefügt wurde (pBottom ist noch NULL).
    Dann muss pBottom entsprechend gesetzt werden. Am Ende wird pTop noch
    auf das nächste ListElem weitergeschaltet.

    pop()

    Wenn pBottom ungleich NULL ist, wird der Wert aus dem ListElem, auf das
    pButtom verweist, als pop-Ergebnis genutzt. Ist pBottom gleich NULL, soll eine
    Fehlermeldung ausgegeben werden. Dann wird pBottom auf den Nachfolger von
    pBottom weitergeschaltet.

    extend()

    In extend wird ein weiteres ListElem angelegt und in die bestehende zyklische
    Liste eingehängt. Hierzu wird das neue Element hinter dem Element eingefügt
    auf das pTop verweist. Der Nachfolger des neuen ListElem ist dementsprechend
    der alte Nachfolger von pTop. Das neue Element wird der neue Nachfolger von
    pTop."



    Hier, was sie dazu schon gemacht hat...

    erst mal Ihre header Datei:

    Quellcode

    1. #ifndef _FIFO_H_
    2. #define _FIFO_H_
    4. class ListenElem{
    5. private:
    6. int value;
    7. ListenElem *pNext;
    9. public:
    10. ListenElem();
    11. //~ListenElem(); // Destruktor
    13. void setValue(int wert);
    14. int getValue(void);
    15. void setNext(ListenElem &le);
    16. ListenElem &getNext(void);
    18. };
    21. class Fifo:ListenElem{
    22. private:
    23. ListenElem *pTop;
    24. ListenElem *pBottom;
    25. unsigned int size;
    28. public:
    29. Fifo(unsigned int groesse);
    30. ~Fifo();
    31. void push(int wert);
    32. int pop(void);
    33. void extend(void);
    35. };
    38. #endif //_FIFO_H_
    Alles anzeigen


    jetzt die Implementierung:

    Quellcode

    1. #include "fifo.h"
    2. #include <iostream>
    3. using namespace std;
    6. ListenElem::ListenElem(){
    8. ListenElem *neu=new ListenElem;
    9. neu->value=0;
    10. neu->pNext=NULL;
    11. }
    14. /*ListenElem::~ListenElem(){ // Destruktor
    15. ListenElem &zeiger;
    16. delete this->value;
    17. zeiger=this->pNext;
    18. delete zeiger;
    20. }*/
    23. void ListenElem::setValue(int wert){
    25. this->value=wert;
    27. }
    30. int ListenElem::getValue(){
    31. return this->value;
    32. }
    34. void ListenElem::setNext(ListenElem &le){
    35. this->pNext=&le;
    36. }
    39. ListenElem &ListenElem::getNext(){
    40. return *(this->pNext);
    41. }
    44. // Implementierungen der Klasse ListenElem:Fifo
    47. Fifo::Fifo(unsigned int groesse=4){
    49. Fifo *neu=new Fifo;
    50. ListenElem anfang;
    52. neu->size=1;
    53. neu->pBottom=NULL;
    54. neu->pTop=&anfang;
    56. anfang.setNext(anfang);
    58. while(neu->size<=groesse)
    59. neu->extend();
    61. }
    64. void Fifo::extend(void){
    66. ListenElem neu;
    67. neu.setNext(*(this->pBottom));
    68. this->pTop->setNext(neu);
    69. //this->pTop=&neu;
    70. this->size++;
    71. }
    74. void Fifo::push(int wert){
    76. //if(this->pBottom==NULL){
    78. this->pTop->setValue(wert);
    79. this->pTop->setNext(this->pTop->getNext());
    82. ListenElem hilf=this->pTop->getNext();
    84. if(this->pBottom==&hilf){
    85. cout<<"\nSchlange voll belegt!"<<endl;
    86. cout<<"\nJetzt wird extend aufgerufen!"<<endl;
    87. extend();
    88. }
    90. if (this->pBottom==NULL){
    91. }
    92. }
    95. //~Fifo();
    96. //int pop(void);
    Alles anzeigen



    Muss erst mal sagen, dass ich die Aufgabenstellung ziemlich restriktiv finde
    und froh bin, dass meine Übungen in Prog freier formuliert waren! (So nach dem Motto: "Das und das soll Ihr Programm können, nun machen Sie mal...")

    Verstehe aber auch, dass so zum Einen der Umgang mit Referenzen/Zeigern und zum Anderen der Zugriff auf Methoden und Eigenschaften
    von Klassen ohne die Vorzüge von "protected" usw. geübt werden soll.

    Setz mich morgen mal dran, obwohl ich eigentlich selbst genug zu tun
    hab (ich sag nur Rekursion in Assembler :twisted: )

    Hab ihren source mal überflogen und find die Ansätze schon ganz nett :wink: ....

    Würd mich über paar Anregungen, Vorschläge und Meinungen zur A-Stellung Eurerseits freuen!

    Wenn Ihr was habt was funzt wie's da steht könnt Ihr's mir auch gern schicken,
    an: whatagoin@web.de

    Schon mal Vielen Dank für Eure posts....

    Man liest sich.....

    greetin's
    Markus