Übersicht

[Coda]

Hi
ist das normal, dass man als anfänger bei solchen Quellcodes schnell die Überischt verliert ? Mein Problem ist, dass ich den code zwar verstehe aber ca. nach der hälfte durcheinander bin und verpeile es irgentwie.

Ich will nur wissen ob das so ist ^^ weil bestimmt gleich welche schreiben das
#include <iostream.h> veraltet ist ^^

thx für Antworten

PS. Ich weiss nicht ob ich den Code aus "Jetzt lerne ich c++" von Markt und Technik posten darf ^^.

// ***********************************************
//    Datei:      Listing 19.1
//
//    Zweck:      Demonstriert verkettete Liste
//    Hinweise:
//
//    COPYRIGHT:  Copyright (C) 1997 Liberty Associates, Inc.
//                All Rights Reserved
//
// Zeigt objektorientierte Lösung für verkettete Listen.
// Die Liste delegiert die eigentliche Arbeit an die
// Knoten. Die Knoten sind abstrakte Datentypen. Es gibt
// drei Knotentypen: Kopfknoten, Endeknoten und interne
// Knoten. Nur die internen Knoten nehmen Daten auf.
//
// Die Klasse Data dient als Objekt, das in der
// verketteten Liste gespeichert wird.
//
// ***********************************************

#include <iostream.h>

enum { kIsSmaller, kIsLarger, kIsSame};

// Data-Klasse für die Speicherung in der Liste
// Jede Klasse in dieser verketteten Liste muß zwei Methoden unterstützen:
// Show (zeigt den Wert an) und Compare (gibt relative Position zurück)
class Data
{
  public:
	Data(int val):myValue(val){}
	~Data(){}
	int Compare(const Data &);
	void Show() { cout << myValue << endl; }
  private:
	int myValue;
};

// Compare entscheidet, wohin ein bestimmtes Objekt
// in der Liste gehört.
int Data::Compare(const Data & theOtherData)
{
	if (myValue < theOtherData.myValue)
		return kIsSmaller;
	if (myValue > theOtherData.myValue)
		return kIsLarger;
	else
		return kIsSame;
}

// Vorwärtsdeklarationen
class Node;
class HeadNode;
class TailNode;
class InternalNode;

// ADT, der das Knotenobjekt in der Liste darstellt
// Alle abgeleiteten Klassen müssen Insert und Show redefinieren
class Node
{
  public:
	Node(){}
	virtual ~Node(){}
	virtual Node * Insert(Data * theData)=0;
	virtual void Show() = 0;
  private:
};

// Dieser Knoten nimmt das eigentliche Objekt auf.
// Hier hat das Objekt den Typ Data.
// Bei der Behandlung von Templates wird eine
// Verallgemeinerung vorgestellt.
class InternalNode: public Node
{
  public:
	InternalNode(Data * theData, Node * next);
	~InternalNode(){ delete myNext; delete myData; }
	virtual Node * Insert(Data * theData);
        virtual void Show() { myData->Show(); myNext->Show(); }  // delegieren!

  private:
	Data * myData;  // Die Daten selbst
	Node * myNext;  // Zeigt auf nächsten Knoten in der verketteten Liste
};

// Der Konstruktor führt nur Initialisierungen aus.
InternalNode::InternalNode(Data * theData, Node * next):
myData(theData),myNext(next)
{
}

// Der Kern der Listenkonstruktion. Stellt man ein
// neues Objekt in die Liste, wird es an den Knoten
// weitergereicht. Dieser ermittelt, wohin das Objekt
// gehört, und fügt es in die Liste ein.
Node * InternalNode::Insert(Data * theData)
{

	// Ist das neue größer oder kleiner als ich?
	int result = myData->Compare(*theData);

	switch(result)
	{
		// Ist das neue gleich groß, kommt es per Konvention vor das aktuelle.
		case kIsSame:   // Gleich zum nächsten case-Zweig
		case kIsLarger: // Neue Daten vor mir einordnen
		{
			InternalNode * dataNode = new InternalNode(theData, this);
			return dataNode;
		}

		// Größer als ich, also an nächsten Knoten
		// weiterreichen. ER soll sich drum kümmern.
		case kIsSmaller:
			myNext = myNext->Insert(theData);
		return this;
	}
	return this;  // Tribut an MSC
}

// Endeknoten ist einfach eine Markierung

class TailNode : public Node
{
  public:
	TailNode(){}
	~TailNode(){}
	virtual Node * Insert(Data * theData);
	virtual void Show() { }

private:

};

// Wenn Daten zu mir kommen, müssen sie vor mir eingefügt werden,
// da ich der Endeknoten bin und NICHTS nach mir kommt.
Node * TailNode::Insert(Data * theData)
{
	InternalNode * dataNode = new InternalNode(theData, this);
	return dataNode;
}

// Kopfknoten hat keine Daten, sondern zeigt einfach
// auf den Beginn der Liste.
class HeadNode : public Node
{
  public:
	HeadNode();
	~HeadNode() { delete myNext; }
	virtual Node * Insert(Data * theData);
	virtual void Show() { myNext->Show(); }
  private:
	Node * myNext;
};

// Nach Erzeugen des Kopfknotens erzeugt dieser
// sofort den Endeknoten.
HeadNode::HeadNode()
{
	myNext = new TailNode;
}

// Vor dem Kopf kommt nichts, also die Daten einfach
// an den nächsten Knoten weiterreichen
Node * HeadNode::Insert(Data * theData)
{
	myNext = myNext->Insert(theData);
	return this;
}

// Ich stehe im Mittelpunkt, mache aber gar nichts.
class LinkedList
{
  public:
	LinkedList();
	~LinkedList() { delete myHead; }
	void Insert(Data * theData);
	void ShowAll() { myHead->Show(); }
  private:
	HeadNode * myHead;
};

// Bei Geburt erzeuge ich den Kopfknoten.
// Er erzeugt den Endeknoten.
// Eine leere Liste zeigt damit auf den Kopf, dieser
// zeigt auf das Ende, dazwischen ist nichts.
LinkedList::LinkedList()
{
	myHead = new HeadNode;
}

// Delegieren, delegieren, delegieren
void LinkedList::Insert(Data * pData)
{
	myHead->Insert(pData);
}

// Rahmenprogramm zum Testen
int main()
{
	Data * pData;
	int val;
	LinkedList ll;

	// Benutzer zum Erzeugen von Werten auffordern.
	// Diese Werte in die Liste stellen.
	for (;;)
	{
		cout << "Welcher Wert? (0 zum Beenden): ";
		cin >> val;
		if (!val)
			break;
		pData = new Data(val);
		ll.Insert(pData);
	}

	// Jetzt Liste durchlaufen und Daten zeigen.
	ll.ShowAll();
        return 0;  // ll verliert Gültigkeitsbereich und wird abgebaut!
}

[THE_FreaK]

Coda schrieb:

Hi
ist das normal, dass man als anfänger bei solchen Quellcodes schnell die Überischt verliert ? Mein Problem ist, dass ich den code zwar verstehe aber ca. nach der hälfte durcheinander bin und verpeile es irgentwie.

Ja

Btw: die Liste find ich persönlich scheiße, da sie kein löschen von einzelelementen zulässt.