www.vorhilfe.de
Vorhilfe

Kostenlose Kommunikationsplattform für gegenseitige Hilfestellungen.
Hallo Gast!einloggen | registrieren ]
Startseite · Forum · Wissen · Kurse · Mitglieder · Team · Impressum
Forenbaum
^ Forenbaum
Status Vorhilfe
  Status Geisteswiss.
    Status Erdkunde
    Status Geschichte
    Status Jura
    Status Musik/Kunst
    Status Pädagogik
    Status Philosophie
    Status Politik/Wirtschaft
    Status Psychologie
    Status Religion
    Status Sozialwissenschaften
  Status Informatik
    Status Schule
    Status Hochschule
    Status Info-Training
    Status Wettbewerbe
    Status Praxis
    Status Internes IR
  Status Ingenieurwiss.
    Status Bauingenieurwesen
    Status Elektrotechnik
    Status Maschinenbau
    Status Materialwissenschaft
    Status Regelungstechnik
    Status Signaltheorie
    Status Sonstiges
    Status Technik
  Status Mathe
    Status Schulmathe
    Status Hochschulmathe
    Status Mathe-Vorkurse
    Status Mathe-Software
  Status Naturwiss.
    Status Astronomie
    Status Biologie
    Status Chemie
    Status Geowissenschaften
    Status Medizin
    Status Physik
    Status Sport
  Status Sonstiges / Diverses
  Status Sprachen
    Status Deutsch
    Status Englisch
    Status Französisch
    Status Griechisch
    Status Latein
    Status Russisch
    Status Spanisch
    Status Vorkurse
    Status Sonstiges (Sprachen)
  Status Neuerdings
  Status Internes VH
    Status Café VH
    Status Verbesserungen
    Status Benutzerbetreuung
    Status Plenum
    Status Datenbank-Forum
    Status Test-Forum
    Status Fragwürdige Inhalte
    Status VH e.V.

Gezeigt werden alle Foren bis zur Tiefe 2

Navigation
 Startseite...
 Neuerdings beta neu
 Forum...
 vorwissen...
 vorkurse...
 Werkzeuge...
 Nachhilfevermittlung beta...
 Online-Spiele beta
 Suchen
 Verein...
 Impressum
Das Projekt
Server und Internetanbindung werden durch Spenden finanziert.
Organisiert wird das Projekt von unserem Koordinatorenteam.
Hunderte Mitglieder helfen ehrenamtlich in unseren moderierten Foren.
Anbieter der Seite ist der gemeinnützige Verein "Vorhilfe.de e.V.".
Partnerseiten
Dt. Schulen im Ausland: Mathe-Seiten:

Open Source FunktionenplotterFunkyPlot: Kostenloser und quelloffener Funktionenplotter für Linux und andere Betriebssysteme
Forum "C/C++" - Templ-Klasse Sortierte Liste
Templ-Klasse Sortierte Liste < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
Ansicht: [ geschachtelt ] | ^ Forum "C/C++"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien

Templ-Klasse Sortierte Liste: Korrektur, Hilfe, Tipp, Idee
Status: (Frage) reagiert/warte auf Reaktion Status 
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: }


        
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
Datum: 19:04 Mo 16.12.2013
Autor: Mija

Kann mir denn wirklich niemand weiterhelfen?

Bezug
        
Bezug
Templ-Klasse Sortierte Liste: Frage (überfällig)
Status: (Frage) überfällig Status 
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: }


Bezug
                
Bezug
Templ-Klasse Sortierte Liste: Fälligkeit abgelaufen
Status: (Mitteilung) Reaktion unnötig Status 
Datum: 00:20 So 05.01.2014
Autor: matux

$MATUXTEXT(ueberfaellige_frage)
Bezug
        
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
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


Bezug
                
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
Datum: 21:07 Sa 21.12.2013
Autor: Mija

Hallo, das mit pastebin.de ist eine gute Idee.
Hier sind die Links zu meinem Code:

[]http://pastebin.de/38114
[]http://pastebin.de/38115

Grüße
Mija

Bezug
        
Bezug
Templ-Klasse Sortierte Liste: Antwort
Status: (Antwort) fertig Status 
Datum: 16:32 So 22.12.2013
Autor: wieschoo

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

Bezug
                
Bezug
Templ-Klasse Sortierte Liste: Frage (beantwortet)
Status: (Frage) beantwortet Status 
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. :-/

Bezug
                        
Bezug
Templ-Klasse Sortierte Liste: Antwort
Status: (Antwort) fertig Status 
Datum: 14:58 Do 02.01.2014
Autor: wieschoo

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!

Bezug
                                
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
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


Bezug
                                        
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
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.


Bezug
                                
Bezug
Templ-Klasse Sortierte Liste: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
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! :-)

Bezug
Ansicht: [ geschachtelt ] | ^ Forum "C/C++"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien


^ Seitenanfang ^
www.vorhilfe.de