Nochmal verkettete Listen C++ < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) überfällig  | | Datum: | 18:18 Do 02.05.2013 | | Autor: | Mija |
| Aufgabe | Schreiben Sie ein C++-Programm, das eine Liste von Feiertagen nach FIFO-Prinzip verwaltet. Es muss auch möglich sein, einen bestimmten Wert in der Liste zu finden.
Ein Listenknoten wird wie folgt definiert:
| 1: | const int MAX = 30;
| | 2: | struct Listenknoten {
| | 3: | char feiertag[MAX];
| | 4: | struct Listenknoten *next;
| | 5: | }; |
a) Bauen Sie Ihr Programm modular auf: Die Liste in einem Modul (fifo_liste.h und fifo_liste.cpp) und das Hauptprogramm im einem anderen Modul.
b) Die Eingabe der Feiertage soll im Dialog mit dem Benutzer passieren. Der Benutzer entscheidet, wann er die Eingabe beendet.
c) Für die Arbeit mit der Liste implementieren Sie folgende Funktionen:
| 1: |
| | 2: | // ein Feiertag am Anfang der Liste einfuegen
| | 3: | void push(char *feiertag);
| | 4: |
| | 5: | // den Feiertag am Ende der Liste zurueckliefern
| | 6: | // und den Knoten entfernen
| | 7: | char *pop(); |
d) Desweiteren implementieren Sie eine Funktion zum Suchen eines bestimmten Knotens in der Liste. Die Funktion liefert einen Zeiger auf den Knoten mit dem als Parameter übergebenen Feiertag oder 0, wenn der Feiertag nicht in der Liste ist.
Listenknoten *find(char *feiertag);
Gestalten Sie die Suche als Dialog mit dem Benutzer.
e) Am Ende des Programms sollen alle Feiertage der Liste vom Ende bis zum Anfang ausgegeben und die Liste dabei geleert werden.
Hinweise:
1. Sie können die Datei lifo_liste.cpp aus moodle als Basis für Ihr Programm benutzen.
2. Wenn Sie in dieser Aufgabe globale Datenobjekte (Variablen, Arrays) brauchen, definieren Sie diese Datenobjekte. |
Hallo, ich habe ein Problem mit der obenstehenden Aufgabe.
Nachdem ich die Feiertage eingegeben habe und dann meine 0 als Abbruchbedingung eingegeben habe, werden nur komische Zeichen in sovielen Zeilen ausgegeben wie ich Eingaben getätigt habe (einschließlich der 0 zum Abbruch).
Leider weiß ich nicht weiter, wo mein Fehler ist. Ich bekomme auch keine Fehermeldungen.
Wo habe ich etwas falsch gemacht?
Ich würde mich sehr freuen, wenn mir jemand weiterhelfen könnte! 
Hier ist mein Code:
| 1: | /*feiertage_fifo.h*/
| | 2: | #ifndef FEIERTAGE_FIFO_H
| | 3: | #define FEIERTAGE_FIFO_H
| | 4: |
| | 5: | const int MAX = 30;
| | 6: |
| | 7: | struct Listenknoten {
| | 8: | char feiertag[MAX];
| | 9: | struct Listenknoten *next;
| | 10: | };
| | 11: |
| | 12: | extern struct Listenknoten* anker;
| | 13: | extern struct Listenknoten* ende;
| | 14: |
| | 15: | //Funktionsdeklarationen
| | 16: | void push(char*);
| | 17: | char* pop();
| | 18: | Listenknoten* find(char*);
| | 19: | void ausgabe();
| | 20: |
| | 21: | #endif //FEIERTAGE_FIFO_H |
| 1: | /*feiertage_fifo.cpp*/
| | 2: | #include <iostream>
| | 3: | #include "feiertage_fifo.h"
| | 4: |
| | 5: | using namespace std;
| | 6: |
| | 7: | // ein Feiertag am Anfang der Liste hinzufuegen
| | 8: | void push(char* feiertag)
| | 9: | {
| | 10: | //Neuer Knoten ANFANG
| | 11: | Listenknoten* neuer_Knoten = new Listenknoten; //erstelle einen neuen Knoten
| | 12: | int i = 0;
| | 13: | while(feiertag[i]!='\0')
| | 14: | {
| | 15: | neuer_Knoten->feiertag[i] = feiertag[i]; // besetze die Daten des Knotens
| | 16: | i++;
| | 17: | }
| | 18: | if( i < MAX-1 )
| | 19: | {
| | 20: | neuer_Knoten->feiertag[i] = '\0';
| | 21: | }
| | 22: | //Neuer Knoten ENDE
| | 23: |
| | 24: | if (anker == 0)
| | 25: | {//die Liste ist leer
| | 26: | anker = neuer_Knoten; //anker zeigt auf neuen Knoten
| | 27: | ende = neuer_Knoten; //ende zeigt auf neuen Knoten
| | 28: | neuer_Knoten->next = NULL; //das Ende der Liste markieren
| | 29: | }
| | 30: | else
| | 31: | {//die Liste ist nicht leer
| | 32: | neuer_Knoten->next = anker; // haenge bisherige Liste an
| | 33: | anker = neuer_Knoten; // aktualisiere den Anfang der Liste
| | 34: | }
| | 35: | }
| | 36: |
| | 37: | // den Feiertag am Ende der Liste zurueckliefern und den Knoten entfernen
| | 38: | char* pop()
| | 39: | {
| | 40: |
| | 41: | char* inhalt = 0;
| | 42: | if (anker != 0)
| | 43: | {
| | 44: | if (anker == ende)
| | 45: | {// Liste besteht aus einem Element, d.h. das erste ist auch das letzte Element
| | 46: | inhalt = anker->feiertag; //Daten fuer die Ausgabe sichern
| | 47: | delete anker;
| | 48: | anker = NULL; //leere Liste herstellen
| | 49: | ende = NULL; // den Zeiger ende aktualisieren
| | 50: | }
| | 51: | else
| | 52: | {// die Liste besteht aus mehreren Elementen
| | 53: | Listenknoten* hilfsknoten = anker;
| | 54: |
| | 55: | //gehe bis zum letzten Element
| | 56: | while (hilfsknoten != 0 && hilfsknoten->next != ende)
| | 57: | {
| | 58: | hilfsknoten = hilfsknoten->next;
| | 59: | }
| | 60: |
| | 61: | inhalt = ende->feiertag; // Daten fuer die Ausgabe sichern
| | 62: | delete ende; // das letzte Element entfernen
| | 63: |
| | 64: | hilfsknoten->next = NULL; //Ende der Liste markieren
| | 65: | ende = hilfsknoten; // den Zeiger aktualisieren
| | 66: | }
| | 67: | }
| | 68: | return inhalt; //die Data des Elements zurueckliefern
| | 69: | }
| | 70: |
| | 71: |
| | 72: | Listenknoten* find(char* feiertag)
| | 73: | {
| | 74: | Listenknoten* knoten = anker;
| | 75: | while(knoten != NULL)
| | 76: | {
| | 77: | int i=0;
| | 78: | while(feiertag[i] == knoten->feiertag[i] && feiertag[i] != '\0' && knoten->feiertag[i] !='\0' )
| | 79: | {
| | 80: | i++;
| | 81: | }
| | 82: | if(knoten->feiertag[i] == feiertag[i])
| | 83: | {
| | 84: | return knoten;
| | 85: | }
| | 86: | else
| | 87: | {
| | 88: | knoten = knoten->next;
| | 89: | }
| | 90: | }
| | 91: | return NULL;
| | 92: | } |
| 1: | /*feiertage_fifo_main.cpp*/
| | 2: | #include <iostream>
| | 3: | #include "feiertage_fifo.h"
| | 4: |
| | 5: | using namespace std;
| | 6: |
| | 7: | struct Listenknoten* anker = 0;
| | 8: | struct Listenknoten* ende = 0;
| | 9: |
| | 10: | int main(void) {
| | 11: |
| | 12: | char feiertag[MAX], element[MAX];
| | 13: | int wahl;
| | 14: |
| | 15: | // fuelle Liste mit Feiertagen, bis eine 0 eingegeben wird
| | 16: | do
| | 17: | {
| | 18: | cout << "Einen Feiertag eingeben (0 == Ende): ";
| | 19: | cin.get();
| | 20: | cin.getline(feiertag, MAX);
| | 21: | if ( feiertag )
| | 22: | push(feiertag);
| | 23: | } while ( feiertag[0] != 0 );
| | 24: |
| | 25: | // gebe in verkehrter Reihenfolge aus und loesche dabei die ausgegebenen Elemente
| | 26: | while (anker != 0)
| | 27: | { // solange die Liste nicht leer ist!
| | 28: | cout << pop() << endl;
| | 29: | }
| | 30: |
| | 31: | cout << endl << "Moechten Sie ein Element suchen? (1=ja, 0=Ende)" << endl;
| | 32: | cin >> wahl;
| | 33: | if (wahl==1)
| | 34: | {
| | 35: | cout << endl << "Welches Element moechten Sie suchen: ";
| | 36: | cin >> element;
| | 37: | Listenknoten* erg = find(element);
| | 38: |
| | 39: | if (erg)
| | 40: | cout << "Element \" " << element << "\" wurde in der Liste gefunden.";
| | 41: | else
| | 42: | cout << "Element " << element << "nicht gefunden." << endl << endl;
| | 43: | }
| | 44: | else
| | 45: | {
| | 46: | cout << endl << "Ende." << endl << endl;
| | 47: | }
| | 48: |
| | 49: | return 0;
| | 50: | } |
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 07:44 Fr 03.05.2013 | | Autor: | Mija |
Kann mir denn niemand weiterhelfen?
|
|
|
| |
|
| Status: |
(Frage) überfällig | | Datum: | 17:09 Fr 03.05.2013 | | Autor: | Mija |
Ich habe jetzt noch eine Funktion Ausgabe geschrieben, die mir die Liste von hinten nach vorne ausgibt, bevor ich mit dem Suchen eines Feiertags beginne.
Leider wird dort immer das nullte Zeichen des jeweiligen Feiertags geschluckt und ich kann nicht finden weshalb.
Nach der Suche nach einem bestimmten Feiertag möchte ich außerdem mit Hilfe der pop()-Funktion alle Feiertage nochmals ausgeben und den Knoten entfernen.
Dort erscheinen bei mir leider immer noch nur seltsame Zeichen.
Ich würde mich sehr freuen, wenn mir jemand bei diesen Problemen noch weiterhelfen könnte.
Vielen Dank.
Hier ist mein Code:
| 1: | #ifndef FEIERTAGE_FIFO_H
| | 2: | #define FEIERTAGE_FIFO_H
| | 3: |
| | 4: | const int MAX = 30;
| | 5: |
| | 6: | struct Listenknoten {
| | 7: | char feiertag[MAX];
| | 8: | struct Listenknoten *next;
| | 9: | };
| | 10: |
| | 11: | extern struct Listenknoten* anker;
| | 12: | extern struct Listenknoten* ende;
| | 13: |
| | 14: | //Funktionsdeklarationen
| | 15: | void push(char*);
| | 16: | char* pop();
| | 17: | Listenknoten* find(char*);
| | 18: | void ausgabe();
| | 19: |
| | 20: | #endif //FEIERTAGE_FIFO_H |
| 1: | #include <iostream>
| | 2: | #include "feiertage_fifo.h"
| | 3: |
| | 4: | using namespace std;
| | 5: |
| | 6: | // ein Feiertag am Anfang der Liste hinzufuegen
| | 7: | void push(char* feiertag)
| | 8: | {
| | 9: | //Neuer Knoten ANFANG
| | 10: | Listenknoten* neuer_Knoten = new Listenknoten; //erstelle einen neuen Knoten
| | 11: | int i;
| | 12: | for (i=0; feiertag[i]!='\0'; i++)
| | 13: | {
| | 14: | neuer_Knoten->feiertag[i] = feiertag[i]; // besetze die Daten des Knotens
| | 15: | }
| | 16: | if( i < MAX-1)
| | 17: | {
| | 18: | neuer_Knoten->feiertag[i] = '\0';
| | 19: | }
| | 20: | //Neuer Knoten ENDE
| | 21: |
| | 22: | if (anker == 0)
| | 23: | {//die Liste ist leer
| | 24: | anker = neuer_Knoten; //anker zeigt auf neuen Knoten
| | 25: | ende = neuer_Knoten; //ende zeigt auf neuen Knoten
| | 26: | neuer_Knoten->next = NULL; //das Ende der Liste markieren
| | 27: | }
| | 28: | else
| | 29: | {//die Liste ist nicht leer
| | 30: | neuer_Knoten->next = anker; // haenge bisherige Liste an
| | 31: | anker = neuer_Knoten; // aktualisiere den Anfang der Liste
| | 32: | }
| | 33: | }
| | 34: |
| | 35: | // den Feiertag am Ende der Liste zurueckliefern und den Knoten entfernen
| | 36: | char* pop()
| | 37: | {
| | 38: | char* inhalt = 0;
| | 39: | if (anker != 0)
| | 40: | {
| | 41: | if (anker == ende)
| | 42: | {// Liste besteht aus einem Element, d.h. das erste ist auch das letzte Element
| | 43: | inhalt = anker->feiertag; //Daten fuer die Ausgabe sichern
| | 44: | delete anker;
| | 45: | anker = NULL; //leere Liste herstellen
| | 46: | ende = NULL; // den Zeiger ende aktualisieren
| | 47: | }
| | 48: | else
| | 49: | {// die Liste besteht aus mehreren Elementen
| | 50: | Listenknoten* hilfsknoten = anker;
| | 51: |
| | 52: | //gehe bis zum letzten Element
| | 53: | while (hilfsknoten != 0 && hilfsknoten->next != ende)
| | 54: | {
| | 55: | hilfsknoten = hilfsknoten->next;
| | 56: | }
| | 57: |
| | 58: | inhalt = ende->feiertag; // Daten fuer die Ausgabe sichern
| | 59: | delete ende; // das letzte Element entfernen
| | 60: |
| | 61: | hilfsknoten->next = NULL; //Ende der Liste markieren
| | 62: | ende = hilfsknoten; // den Zeiger aktualisieren
| | 63: | }
| | 64: | }
| | 65: | return inhalt; //die Data des Elements zurueckliefern
| | 66: | }
| | 67: |
| | 68: |
| | 69: | Listenknoten* find(char* feiertag)
| | 70: | {
| | 71: | Listenknoten* knoten = anker;
| | 72: | while (knoten != NULL)
| | 73: | {
| | 74: | int i=0;
| | 75: | while (feiertag[i] == knoten->feiertag[i] && feiertag[i] != '\0' && knoten->feiertag[i] !='\0' )
| | 76: | {
| | 77: | i++;
| | 78: | }
| | 79: | if (knoten->feiertag[i] == feiertag[i])
| | 80: | {
| | 81: | return knoten;
| | 82: | }
| | 83: | else
| | 84: | {
| | 85: | knoten = knoten->next;
| | 86: | }
| | 87: | }
| | 88: | return NULL;
| | 89: | }
| | 90: |
| | 91: | void ausgabe()
| | 92: | {
| | 93: | Listenknoten* knoten = anker;
| | 94: | while (knoten != 0)
| | 95: | {
| | 96: | cout << endl << knoten->feiertag << endl;
| | 97: | knoten = knoten->next;
| | 98: | }
| | 99: | } |
| 1: | #include <iostream>
| | 2: | #include "feiertage_fifo.h"
| | 3: |
| | 4: | using namespace std;
| | 5: |
| | 6: | struct Listenknoten* anker = 0;
| | 7: | struct Listenknoten* ende = 0;
| | 8: |
| | 9: | int main(void)
| | 10: | {
| | 11: |
| | 12: | char feiertag[MAX], element[MAX];
| | 13: | int wahl;
| | 14: |
| | 15: | // fuelle Liste mit Feiertagen, bis eine 0 eingegeben wird
| | 16: | do
| | 17: | {
| | 18: | cout << "Einen Feiertag eingeben (0 == Ende): ";
| | 19: | cin.get();
| | 20: | cin.getline(feiertag, MAX);
| | 21: | if ( feiertag )
| | 22: | push(feiertag);
| | 23: | } while ( feiertag[0] != 0);
| | 24: |
| | 25: | ausgabe();
| | 26: |
| | 27: | cout << endl << "Moechten Sie ein Element suchen? (1=ja, 0=Ende)" << endl;
| | 28: | cin >> wahl;
| | 29: | if (wahl==1)
| | 30: | {
| | 31: | cout << endl << "Welches Element moechten Sie suchen: ";
| | 32: | cin.get();
| | 33: | cin.getline(element, MAX);
| | 34: |
| | 35: | Listenknoten* erg = find(element);
| | 36: |
| | 37: | if (erg)
| | 38: | cout << "Element \"" << element << "\" wurde in der Liste gefunden.";
| | 39: | else
| | 40: | cout << "Element " << element << " nicht gefunden." << endl << endl;
| | 41: | }
| | 42: | else
| | 43: | {
| | 44: | cout << endl << "Ende." << endl << endl;
| | 45: | }
| | 46: |
| | 47: | // gebe in verkehrter Reihenfolge aus und loesche dabei die ausgegebenen Elemente
| | 48: | while (anker != 0)
| | 49: | { // solange die Liste nicht leer ist!
| | 50: | cout << pop() << endl;
| | 51: | }
| | 52: | cout << endl << endl;
| | 53: |
| | 54: | return 0;
| | 55: | } |
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 19:37 Sa 04.05.2013 | | Autor: | Mija |
Es wäre wirklich super, wenn mir noch jemand weiterhelfen könnte, denn ich habe bald Abgabe!
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 17:38 So 05.05.2013 | | Autor: | Mija |
So langsam bin ich wirklich am Verzweifeln..
Ich kann einfach keinen Fehler finden :-(
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 17:20 Do 09.05.2013 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 18:20 Fr 10.05.2013 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
|
