Templ-Klasse Sortierte Liste < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) reagiert/warte auf Reaktion  | | Datum: | 18:41 Sa 14.12.2013 | | Autor: | Mija |
| Aufgabe | Implementieren Sie die Datenstruktur „sortierter Listen-Container“ als eine Template-Klasse ListenContainerSort. Schreiben Sie die unten folgenden Methoden. Beachten Sie, daß auch im Fall eines leeren Containers die Methoden korrekt arbeiten sollen.
a) Sie sollen zuerst die KlasseListenContainer aus dem Übungsblatt 8 zu Ende implementieren, testen und ihre Arbeitsweise verstehen.
b) Sie können die Klasse ListenContainerSort von der Klasse ListenContainer ableiten oder neu definieren.
c) Entwickeln Sie einen Algorithmus für das sortierte Einfügen von Objekten in den Container. Notieren Sie den Algorithmus in Pseudocode. Implementieren Sie eine Methode insertionSort(const T& obj), die ein Objekt an die richtige Stelle in die Liste einfügt. Dadurch soll es möglich sein, eine sortierte Liste (z.B. aufsteigend) aufzubauen.
Tipp: Für das sortierte Einfügen schreiben Sie eine Hilfsmethode, die Ihnen die Adresse eines Knotens zurückgibt, nach dem der neue Knoten eingefügt werden soll.
d) Schreiben Sie eine Methode ausgabe(), die den gesamten Inhalt des Containers (ohne Verweise) auf der Konsole ausgibt.
e) Schreiben Sie eine Methode size(), die die Anzahl der Objekte im Container zurückgibt.
f) Schreiben Sie eine Methode clear(), die den gesamten Container leert.
g) Schreiben Sie eine Methode empty(), die true zurückgibt, wenn der Container leer ist und false sonst.
h) Implementieren Sie einen geeigneten Destruktor der Klasse.
i) Implementieren Sie eine globale Template-Funktion sort(T* arr, int size), die ein (z.B. mit Pseudozufallszahlen gefülltes) integer-Array und seine Größe als Argumente bekommt, dieses Array dann mit Hilfe der Liste sortiert, und in das Array zurückschreibt.
j) In der main()-Datei sollen Sie die oben beschriebene Funktionalität testen. Das Array für die Funktion sort() kann dynamisch erzeugt werden (der Benutzer gibt die Größe des Arrays über die Tastatur ein) oder ein statisches Array fester Größe sein. Es soll mit Pseudozufallszahlen gefüllt werden. Nach dem Aufruf der Funktion sort() sollen die Zahlen sortiert vorliegen. |
Hallo, ich bin mit der oben genannten Aufgabe eigentlich schon sehr weit, denke ich. Jedoch habe ich noch keinen vernünftigen Konstruktor und Destruktor für die Klasse ListenContainerSort gefunden (ab Zeile 145 in ListenContainerSort.h).
Sollte ich nicht außerdem eigentlich die Methoden, die in ListenContainer zur Verfügung stehen auch in ListenContainerSort nutzen können? Als ich diese in ListenContainerSort noch nicht eingefügt hatte, bekam ich diesbezüglich aber Fehlermeldungen in der main, obwohl sie ja in ListenContainer public sind.
Ich würde mich sehr freuen, wenn mir vor allem wegen des Konstruktors und Destruktors bitte jemand weiterhelfen könnte, denn sonst kann ich ja nichts weiteres testen.
Vielen Dank!
Mija
Mein Code:
ListenContainerSort.h:
| 1: | #include <stdlib.h>
| | 2: |
| | 3: | #ifndef LISTENCONTAINERSORT_H
| | 4: | #define LISTENCONTAINERSORT_H
| | 5: |
| | 6: | template <typename T>
| | 7: | class ListenContainer {
| | 8: |
| | 9: | protected:
| | 10: |
| | 11: | // gekapselte innere Klasse
| | 12: | class Knoten {
| | 13: | public:
| | 14: | T data; // Eintrag = Datenobjekt
| | 15: | Knoten* next; // Verweis auf Nachfolger
| | 16: |
| | 17: | // Konstruktor
| | 18: | Knoten(const T& data, Knoten* next) : data(data), next(next) {}
| | 19: | };
| | 20: |
| | 21: | Knoten* first; // Verweis auf ersten Knoten
| | 22: |
| | 23: | public:
| | 24: |
| | 25: | //Konstruktor
| | 26: | ListenContainer(): first(NULL) {};
| | 27: |
| | 28: | //Destruktor (8b)
| | 29: | ~ListenContainer() { delete[] first; }
| | 30: |
| | 31: | //neuen Eintrag am Anfang der Liste einfuegen
| | 32: | void insertFirst( const T& obj)
| | 33: | {
| | 34: | first = new Knoten(obj, first);
| | 35: | }
| | 36: |
| | 37: | //Eintrag am Anfang der Liste löschen
| | 38: | void removeFirst()
| | 39: | {
| | 40: | if ( first != NULL)
| | 41: | {
| | 42: | Knoten* temp = first;
| | 43: | first = first->next;
| | 44: | delete temp;
| | 45: | }
| | 46: | }
| | 47: |
| | 48: | //(8a) Ausgabe
| | 49: | void ausgabe()
| | 50: | {
| | 51: | Knoten* knoten = first;
| | 52: | cout << endl;
| | 53: | while(knoten != NULL)
| | 54: | {
| | 55: | cout << knoten->data << endl;
| | 56: | knoten = knoten->next;
| | 57: | }
| | 58: | cout << endl;
| | 59: | }
| | 60: |
| | 61: | //(8c) Ist der Container leer?
| | 62: | bool empty()
| | 63: | {
| | 64: | return first == NULL;
| | 65: | }
| | 66: |
| | 67: | //(8d) Wieviele Einträge enthält der Container?
| | 68: | int size()
| | 69: | {
| | 70: | int m=0;
| | 71: | Knoten* lauf = first;
| | 72: | while (lauf != NULL)
| | 73: | {
| | 74: | m++; //Zähle Einträge
| | 75: | lauf = lauf->next;
| | 76: | }
| | 77: | return m;
| | 78: | }
| | 79: |
| | 80: | //(8e) Suche k und gebe aus, ob k gefunden wurde (true) oder nicht (false)
| | 81: | bool find(int k)
| | 82: | {
| | 83: | Knoten* lauf = first;
| | 84: | while (lauf != NULL)
| | 85: | {
| | 86: | if (lauf->data == k)
| | 87: | //return lauf->data; //k wurde gefunden
| | 88: | if (lauf->data > 0)
| | 89: | return true; //k wurde gefunden
| | 90: | lauf = lauf->next;
| | 91: | }
| | 92: | return false; //k wurde nicht gefunden
| | 93: | }
| | 94: |
| | 95: | //(8f) leere den Container
| | 96: | void clear()
| | 97: | {
| | 98: | first = NULL;
| | 99: | delete first;
| | 100: | }
| | 101: |
| | 102: | //(8g) Lösche Eintrag mit Schlüsselwert k aus Container, falls enthalten
| | 103: | int remove(int k)
| | 104: | {
| | 105: | //Nichts zu tun
| | 106: | if (empty())
| | 107: | return 0;
| | 108: |
| | 109: | //1.Fall: Eintrag steht am Anfang
| | 110: | if (first->data == k)
| | 111: | {
| | 112: | first = first->next;
| | 113: | delete first; //Lösche Eintrag bei first
| | 114: | return 0;
| | 115: | }
| | 116: |
| | 117: | //2. Fall: Eintrag muss gesucht werden
| | 118: | Knoten* pred = first;
| | 119: | Knoten* lauf = first->next; //Beginne beim zweiten Eintrag
| | 120: | while (lauf != NULL)
| | 121: | {
| | 122: | if (lauf->data == k)
| | 123: | {
| | 124: | pred->next = lauf->next;
| | 125: | delete lauf; //Lösche Eintrag bei lauf
| | 126: | return 0;
| | 127: | }
| | 128: | pred = lauf;
| | 129: | lauf = lauf->next;
| | 130: | }
| | 131: | return 0;
| | 132: | }
| | 133: |
| | 134: | }; // class ListenContainer
| | 135: |
| | 136: | template <typename T>
| | 137: | class ListenContainerSort : public ListenContainer<T> {
| | 138: |
| | 139: | private:
| | 140: | T data;
| | 141: | //Knoten* next;
| | 142: | ListenContainerSort<T>* next;
| | 143: | public:
| | 144: | /*
| | 145: | // Konstruktor (hier hapert es)
| | 146: | ListenContainerSort(const T& data, Knoten* next) : data(data), next(next) {}
| | 147: | */
| | 148: |
| | 149: | //Konstruktor (hier hapert es)
| | 150: | ListenContainerSort(T elem)
| | 151: | {
| | 152: | ListenContainerSort<T> *neu = new ListenContainerSort<T>();
| | 153: | neu->data = elem;
| | 154: | neu->next = NULL;
| | 155: | }
| | 156: |
| | 157: | ~ListenContainerSort() {delete next* };
| | 158: | /*
| | 159: | //Destruktor (hier hapert es)
| | 160: | ~ListenContainerSort()
| | 161: | {
| | 162: | while(ListenContainerSort->next != NULL)
| | 163: | {
| | 164: | ListenContainerSort<T> *next = ListenContainerSort->next;
| | 165: | delete ListenContainerSort<T>();
| | 166: | ListenContainerSort<T>()= next;
| | 167: | }
| | 168: | delete ListenContainerSort<T>();
| | 169: | }
| | 170: | */
| | 171: |
| | 172: | //(c) Hilfsmethode für das sortierte Einfügen von Objekten
| | 173: | ListenContainerSort* findPreview(const T& obj)
| | 174: | {
| | 175: | Knoten* knoten = first;
| | 176: | while (knoten != NULL)
| | 177: | {
| | 178: | if (knoten->obj == obj)
| | 179: | return knoten;
| | 180: | else
| | 181: | knoten = knoten->next;
| | 182: | }
| | 183: | return NULL;
| | 184: | }
| | 185: |
| | 186: | //(c) Sortiertes Einfügen von Objekten in den Container
| | 187: | void insertionSort(const T& obj)
| | 188: | {
| | 189: | Knoten** p;
| | 190: | for( p = &first; *p != 0; p = &((*p)->next) ){
| | 191: | if ((*p)->data >= obj)
| | 192: | break;
| | 193: | }
| | 194: | *p = new Knoten(obj,*p);
| | 195: | }
| | 196: |
| | 197: | /*
| | 198: | //(c) Sortiertes Einfügen von Objekten in den Container
| | 199: | void insertionSort(const T& obj)
| | 200: | {
| | 201: | Knoten* marker_obj = first;
| | 202: | Knoten* aktuell;
| | 203: | Knoten* letzter;
| | 204: | Knoten* neuer_Knoten = new Knoten;
| | 205: |
| | 206: | neuer_Knoten->obj = obj; // besetze die Daten
| | 207: |
| | 208: | letzter = NULL; // Vorgänger von aktuell
| | 209: | aktuell = first;
| | 210: |
| | 211: | while ((aktuell != NULL) && (aktuell->obj < neuer_Knoten->obj))
| | 212: | {
| | 213: | letzter = aktuell;
| | 214: | aktuell = aktuell->next;
| | 215: | }
| | 216: |
| | 217: | // aktuell zeigt jetzt auf das erste Element, das gleich oder
| | 218: | // größer als neuer_Knoten ist, oder ist NULL, falls am Ende der Liste.
| | 219: | // neuer_Knoten muss vor diesem Element eingehängt werden.
| | 220: | neuer_Knoten->next = aktuell;
| | 221: | if (letzter != NULL) // neuer_Knoten wird nicht erster Eintrag
| | 222: | letzter->next = neuer_Knoten;
| | 223: | else // kein Vorgänger, neuer_Knoten wird erster Eintrag
| | 224: | first = neuer_Knoten;
| | 225: | }
| | 226: | */
| | 227: |
| | 228: | //(d) Ausgabe
| | 229: | void ausgabe()
| | 230: | {
| | 231: | Knoten* knoten = first;
| | 232: | cout << endl;
| | 233: | while (knoten != NULL)
| | 234: | {
| | 235: | cout << knoten->data << endl;
| | 236: | knoten = knoten->next;
| | 237: | }
| | 238: | cout << endl;
| | 239: | }
| | 240: |
| | 241: | //(e) Wieviele Einträge enthält der Container?
| | 242: | int size()
| | 243: | {
| | 244: | int m=0;
| | 245: | Knoten* lauf = first;
| | 246: | while (lauf != NULL)
| | 247: | {
| | 248: | m++; //Zähle Einträge
| | 249: | lauf = lauf->next;
| | 250: | }
| | 251: | return m;
| | 252: | }
| | 253: |
| | 254: | //(f) leere den Container
| | 255: | void clear()
| | 256: | {
| | 257: | first = NULL;
| | 258: | delete first;
| | 259: | }
| | 260: |
| | 261: | //(g) Ist der Container leer?
| | 262: | bool empty()
| | 263: | {
| | 264: | return first == NULL;
| | 265: | }
| | 266: |
| | 267: | }; // class ListenContainerSort
| | 268: |
| | 269: | //globale Tenplate-Funktion
| | 270: | template <typename T>
| | 271: | void sort(T* arr, int size)
| | 272: | {
| | 273: | //Einträge aus dem Array in die Liste einsortieren
| | 274: | for (int=0; i<size; i++)
| | 275: | {
| | 276: | ListenContainerSort* erg = findPreview(arr[i]);
| | 277: | if (erg)
| | 278: | insertionSort(arr[i]);
| | 279: | else
| | 280: | cout << "Liste zu Ende." << endl;
| | 281: | }
| | 282: | //Liste zurück in das Array schreiben
| | 283: | for (int j=0; j<size; j++)
| | 284: | {
| | 285: | arr[j]=insertFirst(j);
| | 286: | }
| | 287: | }
| | 288: |
| | 289: | #endif //LISTENCONTAINERSORT_H |
ListenContainerSort_main.cpp:
| 1: | #include "ListenContainerSort.h"
| | 2: |
| | 3: | #include <iostream>
| | 4: | #include <time.h>
| | 5: | using namespace std;
| | 6: |
| | 7: | int main(void)
| | 8: | {
| | 9: | srand(unsigned(time(NULL)));
| | 10: |
| | 11: | int groesse;
| | 12: | cout << "Welche Groesse soll das Array von Pseudozufallszahlen haben: ";
| | 13: | cin >> groesse;
| | 14: |
| | 15: | int *arr = new int[groesse];// das Array erstellen
| | 16: | for(int i=0; i<groesse; i++)
| | 17: | {
| | 18: | arr[i] = rand(); // mit Zufallszahlen fuellen
| | 19: | }
| | 20: |
| | 21: | //(i),(j) Zufallszahlen-Array in Liste einsortierung
| | 22: | //und in Array zurückschreiben
| | 23: | //(beinhaltet Test von insertionSort() )
| | 24: | ListenContainerSort<int> liste;
| | 25: | sort(arr,groesse);
| | 26: |
| | 27: | //(d) Inhalt des Containers ausgeben
| | 28: | liste.ausgabe();
| | 29: |
| | 30: | //(e) Wieviele Einträge enthält der Container?
| | 31: | cout << "size(): " << liste.size() << endl << endl;
| | 32: |
| | 33: | //(f) leere den Container
| | 34: | liste.clear();
| | 35: | liste.ausgabe();
| | 36: |
| | 37: | //(g) Ist der Container leer?
| | 38: | cout << "empty(): " << liste.empty() << endl << endl;
| | 39: |
| | 40: | return 0;
| | 41: | } |
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 19:04 Mo 16.12.2013 | | Autor: | Mija |
Kann mir denn wirklich niemand weiterhelfen?
|
|
|
| |
|
| Status: |
(Frage) überfällig  | | Datum: | 23:55 Fr 20.12.2013 | | Autor: | Mija |
Hallo zurück, mein Problem mit dem Kontruktor und Destruktor hat sich nun gelöst (siehe Code). Da ich die Klasse ListenContainerSort ja von der Klasse ListenContainer ableite, brauche ich keinen Konstruktor mehr zu verfassen. Den Destruktor habe ich nun allerdings in ListenContainerSort gepackt.
Soweit ist das ja in Ordnung?
Nun habe ich noch Probleme mit meiner globalen Funktion sort() ab Zeile 216 in ListenContainerSort.h. Undzwar bekomme ich folgende Fehlermeldungen:
Fehler 1 error C2955: "ListenContainerSort": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.
Fehler 2 error C3861: "findPreview": Bezeichner wurde nicht gefunden.
Fehler 3 error C2440: '=': 'void' kann nicht in 'int' konvertiert werden
Wie kann ich diese Fehler beseitigen? Es liegt bestimmt daran, dass ich irgendetwas vergessen habe, weil die Funktion ja global sein soll? Wie kann ich hier auf die Methoden aus der Klasse ListenContainerSort zugreifen?
Ich würde mich wirklich sehr sehr freuen, wenn mir nun bitte jemand weiterhelfen könnte! 
ListenContainerSort.h:
| 1: | #include <stdlib.h>
| | 2: |
| | 3: | #ifndef LISTENCONTAINERSORT_H
| | 4: | #define LISTENCONTAINERSORT_H
| | 5: |
| | 6: | template <typename T>
| | 7: | class ListenContainer {
| | 8: |
| | 9: | protected:
| | 10: |
| | 11: | // gekapselte innere Klasse
| | 12: | class Knoten {
| | 13: | public:
| | 14: | T data; // Eintrag = Datenobjekt
| | 15: | Knoten* next; // Verweis auf Nachfolger
| | 16: |
| | 17: | // Konstruktor
| | 18: | Knoten(const T& data, Knoten* next) : data(data), next(next) {}
| | 19: | };
| | 20: |
| | 21: | Knoten* first; // Verweis auf ersten Knoten
| | 22: |
| | 23: | public:
| | 24: |
| | 25: | //Konstruktor
| | 26: | ListenContainer(): first(NULL) {};
| | 27: |
| | 28: | //(8b) Destruktor
| | 29: | ~ListenContainer() { delete[] first; }
| | 30: |
| | 31: | //neuen Eintrag am Anfang der Liste einfuegen
| | 32: | void insertFirst(const T& obj)
| | 33: | {
| | 34: | first = new Knoten(obj, first);
| | 35: | }
| | 36: |
| | 37: | //Eintrag am Anfang der Liste loeschen
| | 38: | void removeFirst()
| | 39: | {
| | 40: | if ( first != NULL)
| | 41: | {
| | 42: | Knoten* temp = first;
| | 43: | first = first->next;
| | 44: | delete temp;
| | 45: | }
| | 46: | }
| | 47: |
| | 48: | //(d) Ausgabe
| | 49: | void ausgabe()
| | 50: | {
| | 51: | Knoten* knoten = first;
| | 52: | cout << endl;
| | 53: | if (knoten == NULL)
| | 54: | cout << "Die Liste ist leer." << endl;
| | 55: | while(knoten != NULL)
| | 56: | {
| | 57: | cout << knoten->data << endl;
| | 58: | knoten = knoten->next;
| | 59: | }
| | 60: | cout << endl;
| | 61: | }
| | 62: |
| | 63: | //(e) Wieviele Eintraege enthaelt der Container?
| | 64: | int size()
| | 65: | {
| | 66: | int m=0;
| | 67: | Knoten* lauf = first;
| | 68: | while (lauf != NULL)
| | 69: | {
| | 70: | m++; //Zaehle Eintraege
| | 71: | lauf = lauf->next;
| | 72: | }
| | 73: | return m;
| | 74: | }
| | 75: |
| | 76: | //(f) leere den Container
| | 77: | void clear()
| | 78: | {
| | 79: | first = NULL;
| | 80: | delete first;
| | 81: | cout << "Liste wurde geleert.";
| | 82: | }
| | 83: |
| | 84: | //(g) Ist der Container leer?
| | 85: | bool empty()
| | 86: | {
| | 87: | return first == NULL;
| | 88: | }
| | 89: |
| | 90: | //(8e) Suche k und gebe aus, ob k gefunden wurde (true) oder nicht (false)
| | 91: | bool find(int k)
| | 92: | {
| | 93: | Knoten* lauf = first;
| | 94: | while (lauf != NULL)
| | 95: | {
| | 96: | if (lauf->data == k)
| | 97: | //return lauf->data; //k wurde gefunden
| | 98: | if (lauf->data > 0)
| | 99: | return true; //k wurde gefunden
| | 100: | lauf = lauf->next;
| | 101: | }
| | 102: | return false; //k wurde nicht gefunden
| | 103: | }
| | 104: |
| | 105: | //(8g) Loesche Eintrag mit Schluesselwert k aus Container, falls enthalten
| | 106: | int remove(int k)
| | 107: | {
| | 108: | //Nichts zu tun
| | 109: | if (empty())
| | 110: | return 0;
| | 111: |
| | 112: | //1.Fall: Eintrag steht am Anfang
| | 113: | if (first->data == k)
| | 114: | {
| | 115: | first = first->next;
| | 116: | delete first; //Loesche Eintrag bei first
| | 117: | return 0;
| | 118: | }
| | 119: |
| | 120: | //2. Fall: Eintrag muss gesucht werden
| | 121: | Knoten* pred = first;
| | 122: | Knoten* lauf = first->next; //Beginne beim zweiten Eintrag
| | 123: | while (lauf != NULL)
| | 124: | {
| | 125: | if (lauf->data == k)
| | 126: | {
| | 127: | pred->next = lauf->next;
| | 128: | delete lauf; //Loesche Eintrag bei lauf
| | 129: | return 0;
| | 130: | }
| | 131: | pred = lauf;
| | 132: | lauf = lauf->next;
| | 133: | }
| | 134: | return 0;
| | 135: | }
| | 136: |
| | 137: | }; // class ListenContainer
| | 138: |
| | 139: |
| | 140: | template <typename T>
| | 141: | class ListenContainerSort : public ListenContainer<T> {
| | 142: |
| | 143: | public:
| | 144: |
| | 145: | //(h) Destruktor
| | 146: | ~ListenContainerSort()
| | 147: | {
| | 148: | while(ListenContainerSort->next != NULL)
| | 149: | {
| | 150: | ListenContainerSort<T> *next = ListenContainerSort->next;
| | 151: | delete ListenContainerSort<T>();
| | 152: | ListenContainerSort<T>()= next;
| | 153: | }
| | 154: | delete ListenContainerSort<T>();
| | 155: | }
| | 156: |
| | 157: | //(c) Hilfsmethode fuer das sortierte Einfuegen von Objekten
| | 158: | ListenContainerSort* findPreview(const T& obj)
| | 159: | {
| | 160: | Knoten* knoten = first;
| | 161: | while (knoten != NULL)
| | 162: | {
| | 163: | if (knoten->obj == obj)
| | 164: | return knoten;
| | 165: | else
| | 166: | knoten = knoten->next;
| | 167: | }
| | 168: | return NULL;
| | 169: | }
| | 170: |
| | 171: | //(c) Sortiertes Einfuegen von Objekten in den Container
| | 172: | void insertionSort(const T& obj)
| | 173: | {
| | 174: | Knoten** p;
| | 175: | for( p = &first; *p != 0; p = &((*p)->next) ){
| | 176: | if ((*p)->data >= obj)
| | 177: | break;
| | 178: | }
| | 179: | *p = new Knoten(obj,*p);
| | 180: | }
| | 181: |
| | 182: | /*
| | 183: | //(c) Sortiertes Einfuegen von Objekten in den Container
| | 184: | void insertionSort(const T& obj)
| | 185: | {
| | 186: | Knoten* marker_obj = first;
| | 187: | Knoten* aktuell;
| | 188: | Knoten* letzter;
| | 189: | Knoten* neuer_Knoten = new Knoten;
| | 190: |
| | 191: | neuer_Knoten->obj = obj; // besetze die Daten
| | 192: |
| | 193: | letzter = NULL; // Vorgaenger von aktuell
| | 194: | aktuell = first;
| | 195: |
| | 196: | while ((aktuell != NULL) && (aktuell->obj < neuer_Knoten->obj))
| | 197: | {
| | 198: | letzter = aktuell;
| | 199: | aktuell = aktuell->next;
| | 200: | }
| | 201: |
| | 202: | // aktuell zeigt jetzt auf das erste Element, das gleich oder
| | 203: | // groesser als neuer_Knoten ist, oder ist NULL, falls am Ende der Liste.
| | 204: | // neuer_Knoten muss vor diesem Element eingehaengt werden.
| | 205: | neuer_Knoten->next = aktuell;
| | 206: | if (letzter != NULL) // neuer_Knoten wird nicht erster Eintrag
| | 207: | letzter->next = neuer_Knoten;
| | 208: | else // kein Vorgaenger, neuer_Knoten wird erster Eintrag
| | 209: | first = neuer_Knoten;
| | 210: | }
| | 211: | */
| | 212: |
| | 213: | }; // class ListenContainerSort
| | 214: |
| | 215: |
| | 216: | //globale Template-Funktion
| | 217: | template <typename T>
| | 218: | void sort(T* arr, int size)
| | 219: | {
| | 220: | ListenContainerSort<int> liste;
| | 221: | //Eintraege aus dem Array in die Liste einsortieren
| | 222: | for (int i=0; i<=size; i++)
| | 223: | {
| | 224: | ListenContainerSort* erg = findPreview(arr[i]);
| | 225: | if (erg)
| | 226: | liste.insertionSort(arr[i]);
| | 227: | else
| | 228: | cout << "Liste zu Ende." << endl;
| | 229: | }
| | 230: | //Liste zurueck in das Array schreiben
| | 231: | for (int j=0; j<size; j++)
| | 232: | {
| | 233: | arr[j]=liste.insertFirst(j);
| | 234: | }
| | 235: | }
| | 236: |
| | 237: |
| | 238: | #endif //LISTENCONTAINERSORT_H |
ListenContainerSort_main.cpp:
| 1: | #include "ListenContainerSort.h"
| | 2: |
| | 3: | #include <iostream>
| | 4: | #include <time.h>
| | 5: | using namespace std;
| | 6: |
| | 7: | int main(void)
| | 8: | {
| | 9: | srand(unsigned(time(NULL))); //Zufallsgenerator generieren
| | 10: |
| | 11: | //Testen der Methoden aus d, e, f, g
| | 12: | int n;
| | 13: | cout << "Eine positive ganze Zahl eingeben: ";
| | 14: | cin >> n;
| | 15: |
| | 16: | ListenContainer<int> liste;
| | 17: |
| | 18: | //Neue Einträge am Anfang der Liste einfuegen (Einträge sind Zufallszahlen)
| | 19: | for (int i = 1; i <= n ; i++ )
| | 20: | liste.insertFirst(rand()%100);
| | 21: | //liste.insertFirst(i);
| | 22: |
| | 23: | //(d) Inhalt des Containers ausgeben
| | 24: | liste.ausgabe();
| | 25: |
| | 26: | //(e) Wieviele Einträge enthält der Container?
| | 27: | cout << "size(): " << liste.size() << endl << endl;
| | 28: |
| | 29: | //(f) leere den Container
| | 30: | liste.clear();
| | 31: | liste.ausgabe();
| | 32: |
| | 33: | //(g) Ist der Container leer?
| | 34: | cout << "empty(): " << liste.empty() << endl << endl;
| | 35: |
| | 36: |
| | 37: | //Testen von sort()
| | 38: |
| | 39: | int groesse;
| | 40: | cout << endl << "Welche Groesse soll das Array von Pseudozufallszahlen haben: ";
| | 41: | cin >> groesse;
| | 42: |
| | 43: | int *arr = new int[groesse]; //das Array erstellen
| | 44: | cout << endl;
| | 45: | if (groesse == 0)
| | 46: | cout << "Das Array ist leer." << endl;
| | 47: | else
| | 48: | {
| | 49: | for(int i=0; i<groesse; i++)
| | 50: | {
| | 51: | arr[i] = rand()%100; //mit Zufallszahlen füllen
| | 52: | cout << arr[i] << endl; //und ausgeben
| | 53: | }
| | 54: | }
| | 55: | cout << endl;
| | 56: |
| | 57: | //(i),(j) Zufallszahlen-Array in Liste einsortierung
| | 58: | //und in Array zurückschreiben
| | 59: | //(beinhaltet Test von insertionSort() )
| | 60: | sort(arr,groesse);
| | 61: |
| | 62: | return 0;
| | 63: | } |
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 00:20 So 05.01.2014 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 17:25 Sa 21.12.2013 | | Autor: | wieschoo |
moin,
vielleicht ist es hilfreicher, wenn du deinen Quelltext auf pastebin.de speicherst und hier nur auf den Quelltext verweist. Man müsste jetzt immer alle Zeilennummern per Hand entfernen.
Ich würde es mir zumindest einmal anschauen
|
|
|
| |
|
Ich habe es noch nicht kompiliert. Pastebin ist etwas augenfreundlicher für Quelltexte.
Welchen Fehler erhälst du, wenn du auf Elternelemente zugreifen möchtest?
Warum verwendest du im Destructor nicht
"removeFirst() " bis die Liste "empty()" ist?
Mich wundert es, das du es überhaupt kompilieren kannst. Ich erhalte etliche Fehlermeldungen:
http://pastebin.de/38124
|
|
|
| |
|
| Status: |
(Frage) beantwortet  | | Datum: | 20:30 So 22.12.2013 | | Autor: | Mija |
Deine Idee zum Desktruktor würde auch funktionieren, danke!
Also wenn ich in der globalen Funktion auf eine Methode aus der Elternklasse zugreifen will, bekomme ich keine Fehlermeldung. Bei Zugriff auf Methoden aus der Kinderklasse auch nicht.
Aber mein Problem ist, dass ich ja eigentlich in der globalen Funktion sort() für den Zugriff auf findPreview ein Objekt der Klasse ListenContainerSort brauche. Da ich der Funktion jedoch nur ein Array und die Größe des Arrays übergebe und innerhalb der Funktion ein Objekt der Klasse ListenContainerSort erstellen soll, habe ich gerade so meine Probleme, vor allem mit dem Zugriff auf findPreview. :-/
|
|
|
| |
|
Da ist doch einiges im Quelltext nicht in Ordnung. In deinem Klassenheader fehlt "using namespace std;" oder besser fast überall "std::".
Manche Deklarationen sind nicht vorhanden.
Ich habe mal alle Compilerfehler bei mir versucht zu beseitigen. Ob Knoten auch eine innere Klasse sein kann, weiß ich nicht.
Der Quelltext:
http://pastebin.com/gyVcMqHU
läuft bei mir und man kann auch auf alle Methoden zugreifen. Ob er fehlerfrei ist, kann nicht nicht bestätigen. Das bezweifleich eher.
Da sich aber sonst keiner fand, musst du wohl mit dieser Antwort auskommen. Dein "sort" ist etwas komisch. Überhaupt schein "knoten" und "listenContainerSort" eher zufällig als Typ gewählt worden zu sein. Ich habe lediglich versucht die Syntaxfehler zu entfernen. Bei der Semantik solltest du vielleicht die Knackpunkte erst einmal als Idee formulieren.
Gesundes neues Jahr!
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 20:59 Do 02.01.2014 | | Autor: | felixf |
Moin,
> Ob Knoten auch eine innere Klasse sein kann, weiß ich nicht.
ja, das geht, und macht man meist auch so :)
(Stichwort "data encapsulation".)
LG Felix
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 18:18 So 05.01.2014 | | Autor: | wieschoo |
Dann hat mindestens eine Person (ich) hier etwas gelernt
Ich fande es nun unter "lokale Klassen". Ok, alles i.O.
Danke.
Ich schätze, sobald das Wort Java hier aufgetaucht wäre, gäbe es mehrere Leute die helfen wollen.
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 13:48 Fr 03.01.2014 | | Autor: | Mija |
Ja, ist schade, dass leider niemand sonst auf meine Frage eingegangen ist. Aber das wird wohl an der Jahreswechsel-Ferien-Zeit liegen.
Vielen Dank für deine Hilfe!
|
|
|
|
![[]](/images/popup.gif){kind=small}
http://pastebin.de/38114
