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

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

Schöner Mist.

chrische

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.

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)

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?

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