listen in c++?

M

mts

Mitglied
hi,

kann ich in c++ mit instanzen auch listen bilden oder so(so das ich wie in c eine liste mit structrurenb bilden kann)?

thx
mts
 
wie?

wie sieht das dann aus, mach ich dann in meiner klasse unter privat(bei den daten) einen pointer der dann auf das nächste element oder auf NULL zeigt????

wie kann ich die instanzen dynamisch erzeugen??? mit sowas wie malloc(ist das nicht new?????). und löschen kann ich glaub mit delete, oder??
 
Ist zwar doppelt verlinkt, aber das Prinzip lässt sich erkennen.


PHP: 
#include <iostream>
using namespace std;

class Knoten
{
public:
	//Konstruktor
	Knoten(void);
	//Konstruktor MK2
	Knoten (char* Name, int Alter);
	//Destruktor
	~Knoten();

	//Methoden
	void SetzteAlter(int Alter);
	void SetzteName(char* Name);

	void SetzteNachfolger(Knoten* Nachfolger);
	Knoten* HoleNachfolger(void);

	void SetzteVorgaenger(Knoten *Vorgaenger);
	Knoten* HoleVorgaenger(void);

	void Ausgabe(void);

	private:
		//Attribute
		char* m_Name;
		int m_Alter;

		//Zeiger auf den nächsten Knoten
		Knoten* m_Nachfolger;
		//Zeiger auf den vorhergehenden Knoten
		Knoten* m_Vorgaenger;
};

Knoten::Knoten(void)
{
	m_Vorgaenger=NULL;
	m_Nachfolger=NULL;
	m_Name=NULL;
	m_Alter=0;
}

Knoten::Knoten(char* Name, int Alter)
{
	m_Vorgaenger=NULL;
	m_Nachfolger=NULL;
	m_Alter=Alter;
	m_Name=new char[strlen(Name+1)];
	strcpy(m_Name,Name);
}


Knoten::~Knoten()
{
	if(m_Name)
	{
		delete m_Name;
	}
}


//Alter zuweisen
void Knoten::SetzteAlter(int Alter)
{
	m_Alter=Alter;
}

//den Namen zuweisen

void Knoten::SetzteName(char* Name)
{
	if(m_Name!=NULL)
	{
		delete m_Name;
	}
	//Feld mit passender Läange reservieren
	m_Name=new char[strlen(Name)+1];
	strcpy(m_Name,Name);
}

//Das Attribut m_Nachfolger aud den übergebenen Wert setzten

void Knoten::SetzteNachfolger(Knoten* Nachfolger)
{
	m_Nachfolger=Nachfolger;
}

//Zeiger auf den Nachfolger zurückgeben
Knoten* Knoten::HoleNachfolger(void)
{
	return m_Nachfolger;
}

//Vorgänger setzten
void Knoten::SetzteVorgaenger(Knoten* Vorgaenger)
{
	m_Vorgaenger=Vorgaenger;
}


//Vorgänger holen
Knoten* Knoten::HoleVorgaenger(void)
{
	return m_Vorgaenger;
}

//Im Knoten gespeicherte Daten ausgeben

void Knoten::Ausgabe(void)
{
	cout<<m_Name<<endl<<m_Alter<<endl<<endl;
}




class Liste
{
public:
	Liste(void); //Konstruktor
	~Liste(void); //Destruktor

	void Hinzufuegen(Knoten* NeuerKnoten);
	void Ausgeben(void);
	void Loeschen(void);

private:
	Knoten* ListenAnfang;
	Knoten* ListenEnde;
};


//Die Zeiger ListenAnfang und ListenEnde mit NULL initialisieren

Liste::Liste(void)
{
	ListenEnde=ListenAnfang=NULL;
}

//Alle Knoten der Liste löschen, wenn die Liste gelöscht wird
Liste::~Liste(void)
{
	Loeschen();
}

//Knoten in die Liste einfügen
void Liste::Hinzufuegen(Knoten* NeuerKnoten)

{
	//Wenn die Liste leer war, müssen sowohl Kopf- als auch Endknoten auf den
	//1. Knoten zeigen
	if(ListenAnfang==NULL)
	{
		ListenAnfang=NeuerKnoten;
		ListenEnde=NeuerKnoten;
	}
	//Ansonsten wird der neue Knoten hinter dem Zeiger Listenende
	//eingefügt, der vorgänger des neuen Knoten ist damit der Knoten, 
	//auf den der Zeiger jetzt zeigt. Zum Schluss muss Listenende noch auf den
	//neuen Knoten gesetzt werden
	else
	{
		ListenEnde->SetzteNachfolger(NeuerKnoten);
		NeuerKnoten->SetzteVorgaenger(ListenEnde);
		ListenEnde=NeuerKnoten;
	}
}

// Alle Knoten der Liste ausgeben
void Liste::Ausgeben()
{
	Knoten* p=ListenAnfang;

	//solange p nicht NULL ist
	while(p)
	{
		//Ausgeben der Attribute
		p->Ausgabe();
		//und p wird auf den NachfolgeKoten von p gesetzt
		p=p->HoleNachfolger();
	}
}


//Alle Knoten der Liste Löschen
void Liste::Loeschen()
{
	while(ListenEnde->HoleVorgaenger())
	{
		ListenEnde=ListenEnde->HoleVorgaenger();
		delete ListenEnde->HoleNachfolger();
		ListenEnde->SetzteNachfolger(NULL);
	}
}



//Demostration der Listenfunktionalität

int main(void)
{
	Liste DieListe;		//Liste instanzieren

	//einen neunen Knoten erzeugen
	Knoten* k=new Knoten("Horst", 12);
	//den Knoten einfügen
	DieListe.Hinzufuegen(k);

	//Noch einen Knoten erzeugen, diesmal noch ohne Inhalt
	k=new Knoten();

	//den Knoten Werte zuweisen
	k->SetzteAlter(32);
	k->SetzteName("Irgendwer");

	//ebenfalls einfügen
	DieListe.Hinzufuegen(k);

	//das Eingegebene ausgeben
	DieListe.Ausgeben();

	//die Liste jetzt löschen
	DieListe.Loeschen();

	return 0;
}
 
Das ist natuerlich eine moeglichkeit
aber wozu das rat neu erfinden und nicht einfach die list aus der
Standartlibrary nehmen ?

Beispiel fuer string:
Code: 
// Template list fuer string instanzieren
list<string> meineListe;

// moegliche methoden

int size() const;
// Anzahl momentaner Elemente

bool empty() const;
// ist leer true.

int max_size() const;
// max Elemente die aufgenommen werden könnte

element front();
// gibt erstes Element zurueck

element back();
// gibt letztes Element zurueck

swap(ContainerTyp Two);
// Vertauscht zwei Container

clear();
// Loescht inhalt der Container

iterator insert(iterator pos, element x);
/* Fuegt an pos das element x ein und gibt iteratorposition des eingefuegten elemets zurück */

iterator erase(iterator pos);
/* loescht element an pos gibt iterator auf dahinter liegende Element zurueck */

iterator erase(iterator anf, iterator end);
/* loescht einschliesslich anf bis ende gibt gibt iterator auf element nach dem geloeschten rurueck */

void splice(itterator pos, list<string>& x)
// fuegt vor pos die liste x ein. Es muss eine andere Liste sein

void splice(iterator pos, list<string> &x, iterator posix)
// fuegt element an der stelle posx der liste x  vor pos ein.

void splce(iterator pos ....

.... //
keine lust mehr ... rest siehe msdn stl list :)
ebenso ist stack<T> deque<T> vector<T> interressant.
 
Die Libaries sind durchaus eine gute Idee :) - aber imo ists nicht schlecht, die Standardalgos/Strukturen mal selber geschrieben zu haben.
 
@Daishi da geb ich dir recht. Meiner Meinung nach, sollte man sich selbst erst mal eine Listen-Klasse aufbauen, bevor man die aus den Lib's verwendet, denn wenn man das Prinzip der einfach- und doppelt verketteten Listen begriffen hat, dann kann man ja immer noch auf die Lib's zurückgreifen.

Gruss Homer (Der sich auch gerade mit solchen Listen beschäfftigt)
 
Juhu, hab's geschafft eine doppelt-verkettete Listen-Klasse zu erstellen und das ganz ohne Lib's.

Gruss Homer (der noch ziemlich am anfang mit C/C++ ist)
 
@Daishi: in deinem programmbeispiel is aber noch ein dicker fehler:

wenn du mehr als 2 elemente in deine liste einfügst wird eine endlosschleife da dann aus irgendeinem grund kein zeiger mehr auf null zeigt.

mfg
leifg
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück