Verkettete Liste mit Objekten

Hallo miteinander,

ich habe eine Verständnisfrage bei der ich nicht so recht weiter komme. Ich beschreibe das Problem einfach mal, also:
Mein Programm enthält eine Klasse Schwein (nur ein par int werte), aus der ich mir beliebig viele neue Objekte erzeugen will (mittels new). Dazu muss ich eine Verkettete Liste verwenden. Dazu benötige ich zwei weitere Klassen eine containerSchwein, und eine knotenSchwein. Allerdings habe ich keine Ahnung wie ich anfangen soll, hat jemand einen nen Tipp für mich? Ich habe keine Ahnung wie ich die Zeiger miteinander verknüpfen soll. Für Hilfe wäre ich echt dankbar.

Grüsse

Hallo

Ich würde für Listen einfach den STL Container

std::list

nehmen.
Als Heder musst du noch

#include<list>

einbinden und los geht's

chrische

ja schon, darf aber nicht verwendet werden.

Hallo

Schöner Mist.

chrische

Vellas

Ich würde es mit einem Template realisieren (nein, ich würde die STL nutzen *g*). Damit kannst du in deine Liste Objekte beliebigen Typs speichern. Dann erstellst du einfach ein Objekt vom Typ Schwein und speicherst es darin. Wüsste nicht wofür man extra eine Klasse knotenSchwein nehmen sollte, außer das das Ding die Listenimplementierung darstellt und man nur Objekte vom Typ containerSchwein akzeptiert.
Template-Liste:

template<class T> class List {
  T object;
  List *next;
public:
  /* Methoden */
};

andere Möglichkeit:

class ContainerSchwein {
  /* Repraesentierung eines Schweins */
};

class KnotenSchwein {
  ContainerSchwein object;
  KnotenSchwein* next;
public:
  /* Methoden */
};

So, dass sollte reichen. Wie eine Liste zu implementieren ist solltest du selbst hinkriegen. Im Internet und auch hier im Forum, sollte man dazu nicht nur Lösungen sondern auch gute Informationen kriegen die einem Helfen sowas zu realisieren.

CStoll

Was ich mir voerstellen könnte, wäre auch noch so etwas:

class Knoten
{
  Schwein Daten;
  Knoten* next;
  friend class Container;
}

class Container
{
  Knoten* first;
  int count;
public:
  //Zugriffsfunktionen
}

(Container verwaltet die komplette Listenstruktur, Knoten ein einzelnes Listenelement)

Sodale, schon mal danke für eure Hilfe. Bis jetzt bin ich so weit:

main:

#include "schwein.h"

int main(){
	schwein *ps;
	schwein *anfang = 0;
	schwein *ende = 0;
	char x;

	do{
		cout << "n : neues Schwein initialisieren" << endl;
		cout << "a : Schwein ausgeben" << endl;
		cout << "q : Ende" << endl;
		cin >> x;

		switch (x){
			case 'n' : ps = new schwein;
					   ps ->p = 0;
					   ps ->init();		   
					   if( ende != 0) ende->p = ps;
					   else anfang = ps;
					   ende = ps;

					   break;

			case 'a' : for (schwein *i = anfang; i != 0; i = i->p){
						i->print();
						}
					   break;
		}
	}while ( x != 'q');
}

Klasse Schwein:

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class schwein{
	private:

		int anzahl;

		int groesse;
		char name[20];
		int faulheit;

	public:
		void init();
		void print();
		schwein *p;

};

void schwein :: init(){

	cout << "Bitte die Groess eingeben: " << endl;
	cin >> groesse;

	cout << "Bitte den Namen des Tieres eingeben: " << endl;
	cin.sync();
	cin.getline(name, 20);

	cout << "Bitte den Grad der Faulheit eingeben: " << endl;
	cin >> faulheit;
}
void schwein :: print(){
	cout << left <<setw(10) << groesse << setw(10) <<name << setw(10) <<faulheit << endl;
}

class container{

};

class knoten{

};

Wie kann ich jetzt aber die Initialisierung eines neuen Schweines, und die Verwaltung in die Klassen container und knoten bringen?

ZuK

Globalist schrieb:

Wie kann ich jetzt aber die Initialisierung eines neuen Schweines, und die Verwaltung in die Klassen container und knoten bringen?

Die Initialisierung eines Schweines hat in container und knoten nichts verloren.
Ebenso braucht das schwein keinen pointer auf ein anderes schwein. Das ist die Aufgabe des knotens.
Knoten sollte dann ungefähr so aussehen ( nehmen wir an du willst einen container von pointern auf schwein )

class knoten{
public:
    knoten( schwein * s ):data(s), next(0) {}
    schwein * getdata() { return data; }
    knoten * getnext() { return next; }
    friend class container;  // damit container direkt auf data und next zugreifen kann
protected:
    schwein * data;
    knoten * next;
};

Die klasse container verwaltet dann die knoten.
Kurt

Jo danke für deine Mühe
Gruss

So nochmal ich, irgendwie fehlt mir der springende Gedanke. Es ist so dass ich eine Klasse container und Knoten nehmen muss. Der Knoten verwaltet das aktuelle Element und in kontainer befinden sich alle. Wenn ich mir jetzt ein neues Schwein erstelle wie speicher ich es dann? Ich habe so dass Gefühl dass mir der Ansatz fehlt. Wie wirkt alles zusammen?

ZuK

Als Ansatz.
Der Benutzer deines containers sollte nichts über die implementations details des containers ( sprich knoten klasse ) wissen müssen. Die Verwaltung der Schweine liegt also ganz und gar in der Verantwortung des containers.
Der container braucht also Funktionen um ein schwein einzufügen und ein bestimmtes schwein aus der Liste zu entfernen. Dann muss der container noch irgendwie Zugriff auf alle von ihm verwalteten schweine ermöglichen. Üblicherweise stellt der container dazu iterator-funktionen ( z.b get_first(), get_next() ) zur verfügung.
Nützliche Funktionen der container-klasse wären dann noch get_anzahl() oder ist_leer().
Hoffe das hilft dir weiter.
Kurt

dankeschön