Grafi Orientiert Sich Ihnen

Das erste Zeugnis der Beschäftigung des grafi lachte sie bis 1736, als Leonhard Euler sie benutzte, um das klassische Problem den Brücken von Koenigsberg zu beheben, wohin der Pregal Fluß um die Insel von Kneiphof schiebt. Es gibt vier feste Länder, die von den Buchstaben zu, B, C, D in Tabelle 1 gekennzeichnet werden, daß sie diesen Fluß zu ihren Rändern haben. Sieben Brücken kennzeichnen zu Ihnen von den Buchstaben fungieren, anschließen vier feste Länder. Das Problem der Brücke von Koenigsberg ist folgend: verlassend von einer festen Masse, ist es möglich, zum Position iniziale nachher zurückzugehen, jede Brücke eine einzelne Zeit gekreuzt zu haben?

Eine mögliche Weise ist folgend:

· Von der festen Masse B gehen

· Die Brücke in zum Auftrag kreuzen, der herauf die Insel zu sich verfängt

· Die Brücke benutzen und zwecks sich den D Bereich oben verfangen

· Die Brücke g benutzen, um sich Bereich C oben zu verfangen

· Die Brücke d benutzen, um sich den Bereich zu oben zu verfangen

· Die Brücke b benutzen, um sich den B Bereich oben zu verfangen

· Die Brücke f benutzen, um sich den D Bereich oben zu verfangen

Dieser Abstand kreuzt nicht alle auch nicht Brücken führt zu die Position der B. Abfahrt Euler entdeckte, daß Leute von Koenigsberg nicht jede Brücke eine einzelne Zeit kreuzen und in die Abfahrtposition zurückkommen können. Euler in dem behob das Problem mit Diagramm (ein Vervielfältigungsapparat in den Effekten) feste Länder, die, sie Sie Interesse ( oder Nullpunkte zu uns) waren und die Brücken waren die Seiten ( Bogen ). Seine Lösung ist nicht nur elegant, aber sie trifft auf das ganzes grafi zu.

Euler definierte den Grad einer Spitze wie der Zahl Seiten Ereignissen auf ihm, auch demonstriert, daß ein Abstand dieser Urlaub von einer Spitze besteht, welches, eine einzelne Zeit jede Seite kreuzt und Ende in der Spitze sie nur anfängt, wenn und wenn der Grad jeder Spitze gleich ist. Ein ähnlicher Abstand wird umfaßt von Euler genannt. Dieser Abstand besteht nicht für die Brücken von Koenigsberg, in, wieviel alle Interessen vom ungleichen Grad ist.

Von dieser ersten Anwendung ist das grafi Gebrauch in einer unermeßlichen Strecke Sie von Anwendungen, wie der Analyse der elektrischen Arbeiter der Stromkreise, der Planung der Pläne, der Kennzeichnung der Chemikaliemittel oder der Ermittlung der kürzeren Straßen gewesen.

2) Definitionen

Ein Diagramm ist es eine Ansammlung, die zwei Sätze enthält, einer von Ihnen Interesse zu uns und einer von Bögen, während mit, das ihm, können Bögen es sind leer, mit Interessen zu uns, wenn das Diagramm es besteht, pu², sich nicht aus leerem zu drehen. Eine Spitze auch wird Nullpunkt und die strukturelle Elementunterseite des Diagramms genannt festsetzt. Ein Bogen ist der LOGON zwischen zwei Interessen zu uns, wenn er, den Bögen es des Diagramms sind, sich orientiert Ihnen, dann über das Diagramm gesprochen wurde, das anders orientiert wurde, wurde gesprochen über nicht das orientierte Diagramm.

Zu jeder Spitze und zu Bogen können sie von den Aufklebern verbunden sein, wenn der wurde gesprochen über das Diagramm geschieht, das in den Interessen mit uns beschriftet wird, oder in ihm Bögen, die zwei Aufkleberbögen, verschieden nicht notwendigerweise sein müssen, ist möglich, um zwei Bögen mit dem gleichen Attribut zu haben. In dem im Fall die Aufkleber werden sie von den gesamten Zahlen festgesetzt oder sie und die Elemente des Diagramms, das dezimieren sie in bestellter Weise beschriftet werden, dann wurden über das gewogene Diagramm gesprochen.

Zu orientiert innerhalb eines Diagramms, wird Weise eine Reihenfolge von Interessen zu uns so definiert, daß ein Bogen zwischen jeder Spitze besteht und daß aufeinanderfolgendes. Die Länge der gleichen Weise e ' zur Zahl Bögen, denen sie Sie Interesse an uns anschließen. Eine einzelne Spitze setzt eine Weise von Länge null fest. Die Weise sagt einfaches, wenn, zum Innere der Weise, sie nicht, die Sie bestehen, Interesse zu uns, daß sie mehr als einmal erscheinen, im konträren Fall besagtes nicht einfaches ist. In einem Diagramm orientiert, in einem Zyklus e ' eine Weise der grösseren oder gleichen Länge zu der, die es anfängt und es beendet auf der gleichen Spitze. Ein Diagramm ist es definiertes zyklisches, wenn in ihm es gibt, oder mehr Zyklen, im konträren Fall, wir sagen, daß das Diagramm es azyklisch ist. Von im orientierten Fall vom Diagramm, sagt man, daß der Vj Nullpunkt neben dem Nullpunkt ist Sie, wenn ein Bogen wem Urlaub und Sie zu Ihnen in Vj erreichen, solcher Bogen kommt besagtes Ereignis zu den Nullpunkten VI und Vj besteht. Im Fall, in dem er muß ist, daß, bildend mit einem Diagramm, das nicht orientiert wird, er nicht Richtung hat, über Sie Interesse zu sprechen mit uns angrenzend in, wieviel solche Definition nah an das Bogenkonzept orientato gebunden wird (Bogen in, das e ' wichtiger Auftrag seines Übermaßes zeigt).

Von jedem Spitze pu² zum dipartirsi kommen eine imprecisato Zahl von ihr Bögen, die in einem beenden können, welches des Interesses wir des Diagramms, es geschehen können das von einer dipartano Spitze, zwei, die es gewölbt wird, daß beide im gleichen Spitze Ende, das von diesem der Abfahrt, in diesem Fall Sie verschieden ist, uns der Abfahrt betreffen und der Ankunft für jeden Bogen sie Gleichgestelltes sind, solche Bögen Sayings- Ähnlichkeiten, ein Diagramm, das nicht Bogenähnlichkeiten ist besagtes einfaches enthält.

Für eine Spitze wird der Grad als die Zahl von Bögen relati Sie zu ihm definiert, gerechter, wurde gesprochen über Einkommengrad, um die Zahl Bögen anzuzeigen, denen sie im betrachteten Spitze e Grad des Entweichens beenden , um die Zahl Bögen anzuzeigen, die dipartono von der betrachteten Spitze. Eine Spitze, die einen ungültigen Grad hat, ist besagtes lokalisiert und stellt eine Spitze von dar, welchem dipartono keine sie nicht erreichte Bögen sind. Ein Diagramm ist sie angeschlossen besagtes, wenn es einen Abstand zwischen jeder Klammer der Nullpunkte gibt, die das Diagramm selben offensichtlich ein Diagramm betreffen, daß es Nullpunkte enthält, die Isolate zu Ihnen nicht angeschlossen wird.

Ein Diagramm eins sagt nah angeschlossen wenn für jede Spitze besteht ein direkter Abstand, der in Richtung zu anderer Spitze jeder ist. Die Abbildungen, die folgen, veranschaulichen einem Diagramm beschriftet orientiert (auf dem links) und das nicht orientierte beschriftete entsprechende Diagramm (rechts).

, irgendeine allgemeine Idee auf der Art der abstrakten Daten GRAFO nachher geliefert zu haben, mach's gut wir Stunde, um von der Stunde die Darstellung zu definieren.

3) Darstellung des abstrakten Daten Diagramms

Eine Weise, das abstrakte Daten Diagramm darzustellen bekannt mit dem Namen der Matrix des Angrenzens, in solchem Fall, ein Diagramm wird dargestellt von einer quadratischen Matrix des N Auftrages, in dem N die Zahl Interessen wir betreffend das Diagramm ist, sie sind im Korrespondenz biunivoca mit den Werten der Indizes der Linie und der Spalte von der quadratischen Matrix. Die Elemente der Matrix sind von der booleano Art und ihr Wert kommt hergestellt von der folgenden Richtlinie:

das Element in der Linie und in der Spalte J $$$IST zutreffendes, wenn im Diagramm ein Bogen von der Spitze zur Spitze J besteht, wertIST andernfalls falsches wert.

Eine "Schleife" wird vom zutreffenden Wertplatz im Fall dargestellt, der von gekennzeichnet wird (i , i).

Vorteile : Solche Darstellung ist viel einfaches und kleiner stimmt der geverwiesene Zugang mit den relativen Informationen zum Bestehen überein oder, als ein Bogen, der zwei Sie anschließt, zu uns betreffen

Nachteile : ein Diagramm, das von N festgesetzt wird, das, Sie zu uns, Nachfragen ein matrice N xN, dieses betreffen, ist ein Problem, wenn das numero von Ihnen cresce poiché Zunahmen betreffen das Gedächtnis zu uns remarkablly besetzte. Ein ein anderer Nachteil dieser Darstellung besteht das gebildete nel, daß wir nicht die Zahl von Ihnen erhöhen können betreffen uns, daß vom Diagramm nicht außerdem sein kann dargestelltes grafi, in dem sie Bogenähnlichkeiten erscheinen.

Entsprechend Art der Darstellung, die ein Diagramm beim Darstellen durch eine Liste von sottoliste, solche Darstellung besteht, mit dem Namen der Liste des Angrenzens, istalle Interessen zu uns des Diagramms wird eingesetzt in einer Liste berühmt und jede Spitze hat, verbunden wenn, eine entferntere Liste, die alle Bögen es enthält, daß sie von solcher Spitze entstanden werden.

Vorteile : die Gedächtnisanforderung kommt, von der wirkungsvollen Zahl Interessen zu uns nur abzuhängen und Bögen, daß sie das Diagramm außerdem die Darstellung festsetzen, ist Dynamik

Nachteile : der Zugang zu einem Element des Diagramms wird nicht verwiesen, aber er benötigt das scansion der Liste

In unserem Fall zwecks das Diagramm zu verwirklichen , ziehen wir in Betracht die Darstellung mittels der Liste des Angrenzens, des Diagramms, das wir eine Darstellung begrenzt von der einzelnen Verwendbarkeit des Gedächtnisses des Systems betrachten, dem Werkzeuge es (unbegrenzte Form) außerdem die Darstellung von uns gezogen in Betracht den Gedächtnisraum handhaben, der für etwaige Annullierungen verursacht wird.

Die Kompliziertheit des Algorithmus, der das grafi einführt, orientiert sich Ihnen hat getragen sehen, daß wieder die Annäherung an das Problem in sottoproblemi der minderwertigen Kompliziertheit ausgedrückt, die gewesen ist, zu Ihnen einzigartig und nachher es zu Ihnen optimiert koordiniert. Dieser gleiche logische Abstand wird in das trattazione gefolgt, das folglich artikuliert in den folgenden Punkten ausfällt:

) Position in der der Gegenstandunterseite das Problem zerlegend

B) Beschreibung und Implementierung des polimorfismo

c) Entwicklung eines applicativo basiert auf Kategorie DIAGRAMM

gegen) Position wendet Unterseite ein

Eins des möglichen Informatik rappresentazioni des grafi ist diese der Angrenzenlisten, die, wie vorher herausgestellt, auf einer enthaltenen Liste alles Interesse basieren, das Teil zu uns des Diagramms von jeder bildet, von dem die Liste des Bogens abgehend von der gleichen Spitze entstehen Sie.

In diesem optischen fällt es genügend intuitivo aus, um zu kennzeichnen, dem primitivo Gegenstand, der nicht andere Gegenstände das ARC_NODE benutzt, nachher Gegenstand ARC_LIST kennzeichnet, der die Liste ist, die das ganzes ARC_NODE sich wiedervereinigt und in der logischen Entwicklung fortfährt, die, das dipana von dem VERTEX_NODE das ARC_LIST gehabt wird und schließlich wird das VERTEX_LIST gehabt, das einen logischen Gesichtspunkt übereinstimmt mit Gegenstand GRAFO gibt.

Wir führen Stunde zur Analyse der einzelnen Gegenstände im überbelichteten Auftrag:

ARC_NODE

//Arc_Node.h: Schnittstelle für die Arc_Node Kategorie.

# if!defined(AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Element.h" mit ein

Kategorie Arc_Node

{

Freundkategorie Arc_List;

geschützt:

Gen_Data_Ptr Arc_Destination;

Gen_Data_Ptr Arc_Attribute;

Arc_Node * Next_Arc;

Öffentlichkeit:

leeres Display_An_Arc();

Arc_Node(Gen_Data_Ptr The_Attribute, Gen_Data_Ptr The_Destination);

virtuelles ~Arc_Node();

};

# endif / /!defined(AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _)

Da das Arc_List ist erklärter Freund betrachtet wird, der folglich ist, sich den Daten zu nähern, die im privaten Teil beschrieben werden, das 2 gunlayers der Gen_Data_Ptr Art ist, die im Kategorie ELEMENT definiert wie ein gunlayer zu einem Gegenstand der Art ELEMENT kommt. Diese 2 gunlayers stimmen folglich, überein die Art nicht zu binden keine des Attributes des Bogens vom Attribut der Bestimmungsortspitze. Ein gunlayer zum aufeinanderfolgenden Nullpunkt in der Liste wird dann von den zugehörigen Bögen eine Datenspitze gehabt.

Die Betriebe, die auf jedem Gegenstand der Art ARC_NODE definiert werden, sind seine Kreation und zeitgenössische Initialisierung, die Zerstörung und die folgende Erklärung der Sichtbarmachung zweite:

//Arc_Node.cpp: Implementierung der Arc_Node Kategorie.

# schließt sie "Arc_Node.h" mit ein

# schließt sie < iostream.h > mit ein

//Construction/Destruction

Arc_Node::Arc_Node(Gen_Data_Ptr The_Attribute, Gen_Data_Ptr The_Destination)

{

Arc_Attribute = The_Attribute;

Arc_Destination = The_Destination;

}

Arc_Node::~Arc_Node()

{

}

//Anzeige

Lücke Arc_Node::Display_An_Arc()

{

Arc_Attribute->Display();

cout < < "-->";

Arc_Destination->Display();

cout < < "\t";

}

Das Display_An_Arc bildet nicht anderes, das, um die Anzeige Methode anzuwenden für Kategorie ELEMENT und seine abgeleiteten Kategorien zu Arc_Attribute und zu Arc_Destination definierte, die gunlayers zu dieser Kategorie sind und folglich die Sichtbarmachung des Attributes des Bogens und der Spitze des Bestimmungsortes erhalten.

ARC_LIST

//Arc_List.h: Schnittstelle für die Arc_List Kategorie.

# if!defined(AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Arc_Node.h" mit ein

Kategorie Arc_List

{

geschützt:

Arc_Node * Arc_List_Head;

Öffentlichkeit:

Arc_Node * Is_Member_Of(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Destination);

leeres Clear();

internes Number_Of_Arcs_In();

bool Remove(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Destination);

leeres Display_Arcs();

leeres Insert(Gen_Data_Ptr The_Attribute, Gen_Data_Ptr The_Destination);

Arc_List();

virtuelles ~Arc_List();

};

# endif / /!defined(AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _)

Die einzigen geschützten Daten dieser Kategorie sind ein gunlayer zu einem ARC_NODE, das es das erste der Liste der Bögen ist, die von der Datenspitze abgehend sind, für die die Kategorie es istanziata kommt. Im allgemeinen Teil gibt es die Definition der Betriebe eseguibili Standards auf einer Liste, ihre Erklärung ist folgend:

//Arc_List.cpp: Implementierung der Arc_List Kategorie.

# schließt sie < iostream.h > mit ein

# schließt sie "Arc_List.h" mit ein

//Construction/Destruction

Arc_List::Arc_List()

{

Arc_List_Head = 0;

}

Arc_List::~Arc_List()

{

}

//Inserzione eines Elements im Kopf zur Liste der Bögen, Gedächtnisse, die in der Darstellung von uns sie vorstellten, hat nicht

//alcun Richtung, eine saubere Einfügung der Bögen genau für die heterogene Natur der Daten vorher zu sehen behandelt zu Ihnen.

leeres Arc_List::Insert(Gen_Data_Ptr The_Attribute, Gen_Data_Ptr The_Destination)

{

Arc_Node * Arc_Node_Ptr;

//Vertex_Node_Ptr Spitze zu einem neuen Vertex_Node

Arc_Node_Ptr = neues Arc_Node(The_Attribute, The_Destination);

//places im Kopf zur Liste die neue Spitze

if(Arc_List_Head == 0)

{ //EMPTY LISTE

Arc_List_Head = Arc_Node_Ptr;

Arc_Node_Ptr->Next_Arc = 0;

}

sonst

{ //NOT LEEREN LISTE

Arc_Node_Ptr->Next_Arc = Arc_List_Head;

Arc_List_Head = Arc_Node_Ptr;

}

//visualization aller Bögen es betreffend die Liste

Lücke Arc_List::Display_Arcs()

{

if(Arc_List_Head == 0)

{

cout < < "\tNo Bogen verlassen von diesem Gipfel" < < endl;

}

sonst

{

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Arc_List_Head;

while(Arc_Node_Ptr! = 0)

{// der Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Arc_Node_Ptr->Display_An_Arc();

Arc_Node_Ptr = Arc_Node_Ptr->Next_Arc;

}

//Elimination eines Bogens von der Liste

bool Arc_List::Remove(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Destination)

{

//Punkt ein gunlayer zum Kopf der Liste

Arc_Node * Arc_Node_Ptr_1;

Arc_Node * Arc_Node_Ptr_2;

Arc_Node_Ptr_1 = Arc_List_Head;

Arc_Node_Ptr_2 = Arc_List_Head;

//search des zu entfernen Nullpunktes

while((Arc_Node_Ptr_1! = 0) &&

((!(The_Arc->Is_Equal(Arc_Node_Ptr_1->Arc_Attribute))) ||

(!(The_Destination->Is_Equal(Arc_Node_Ptr_1->Arc_Destination)))))

{

Arc_Node_Ptr_2 = Arc_Node_Ptr_1;

Arc_Node_Ptr_1 = Arc_Node_Ptr_1->Next_Arc;

}

if(Arc_Node_Ptr_1! = 0)

{// HABE ich das ELEMENT GEFUNDEN, UM ZU ENTFERNEN

if(Arc_Node_Ptr_1! = Arc_List_Head)

Arc_Node_Ptr_2->Next_Arc = Arc_Node_Ptr_1->Next_Arc;

sonst ist der ZU ENTFERNEN BOGEN DER ERSTE der LISTE

Arc_List_Head = Arc_List_Head->Next_Arc;

//elimination des Bogens

Löschung Arc_Node_Ptr_1;

Rückhol richten Sie aus;

}

sonst

{// ELEMENT NICHT GEFUNDEN

Rückholfalsches;

}

//it gibt zurück die Zahl den Bögen, die von einer Spitze abgehend sind

internes Arc_List::Number_Of_Arcs_In()

{

internes N_Arcs = 0;

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Arc_List_Head;

while(Arc_Node_Ptr! = 0)

{// der Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

N_Arcs;

Arc_Node_Ptr = Arc_Node_Ptr->Next_Arc;

}

Rückholn_Arcs;

}

//This Mitgliedsfunktion mach's gut, zum aller Bögen zu ihr zu annullieren Geschenk in der Liste

Lücke Arc_List::Clear()

{

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Arc_List_Head;

while(Arc_Node_Ptr! = 0)

{// der Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Remove(Arc_Node_Ptr->Arc_Attribute, Arc_Node_Ptr->Arc_Destination);

Arc_Node_Ptr = Arc_List_Head;

}

//Questa Funktion mach's gut, zum herzustellen, wenn Marken eines Datenbogens bereits von der Liste bewerkstelligt sie zerteilen und im Fall der Bogen kommt

//individuato einige, die es zurück ein gunlayer zu ihm kommt gibt anders, das gunlayer der feinen Liste zurück gegeben, die 0 ist

Arc_Node * Arc_List::Is_Member_Of(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Dest)

{

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Arc_List_Head;

while((Arc_Node_Ptr! = 0) &&

(!(The_Arc->Is_Equal(Arc_Node_Ptr->Arc_Attribute))) &&

(!(The_Dest->Is_Equal(Arc_Node_Ptr->Arc_Destination))))

{

Arc_Node_Ptr = Arc_Node_Ptr->Next_Arc;

}

Rückholarc_Node_Ptr;

}

Sie beachten sich, daß in ENTFERNEN und im IS_MEMBER_OF ich es der Methode verwenden IS_EQUAL, die auf Art ELEMENT definiert wird und zu Ihnen ableiten, dem sie übereinstimmt, die Gleichheit der Datenziele von das 2 gunlayers previa der Umwandlung zu Ihnen mittels Type_Casting vom gunlayer zu einem Gegenstand ELEMENT zum gunlayer zu FLOAT_OBJ oder CHAR_OBJ oder INT_OBJ herzustellen.

VERTEX_NODE

//Vertex_Node.h: Schnittstelle für die Vertex_Node Kategorie.

# if!defined(AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Graph.h" mit ein

# schließt es "Arc_List.h" mit ein

Kategorie Vertex_Node

{

Freundkategorie Diagramm;

geschützt:

Gen_Data_Ptr Vertex_Attribute;

nicht unterzeichnetes internes Reference_Count;

Arc_List * Arc_List_Ptr;

Vertex_Node * Next_Vertex;

Öffentlichkeit:

leeres Display_Vertex_And_Arcs();

leeres Display_Vertex();

Vertex_Node(Gen_Data_Ptr The_Attribute);

virtuelles ~Vertex_Node();

};

# endif / /!defined(AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _)

Auch in diesem Fall kommt es definiert wie das Freundkategorie DIAGRAMM (dieses erinnern uns wir an Äquivalent zum VERTEX_LIST), wieviel freies haben muß, im Zugang zu fängt vom einzelnen Vertex_Node auf, von dem gebildet wird. Im Segment, das den Informationen geschützt wird, erscheinen Sie von, welchem jedes Vertex_Node gebildet wird, das ein Attribut ist, dessen Art ein priori nicht Grenze an zweiter Stelle kommt, wieviel bereits beschrieben für das Vertex_Node, gesamtes Positiv die Anzeige einer Anzahl von den Bögen, die in die Spitze, Informationen des Primärwert allorchè hereinkommen, entschieden werden muß, wenn die Spitze dismissable oder kleiner ist, ist dann ein gunlayer zu einer Art ARC_LIST folglich jede Spitze weiß, wo es die Liste seiner abgehenden Bögen anfängt. Schließlich es gibt ein gunlayer zum folgenden VERTEX_NODE im VERTEX_LIST.

Wir führen Stunde zur Erklärung der Mitgliedsfunktion:

//Vertex_Node.cpp: Implementierung der Vertex_Node Kategorie.

# schließt sie < iostream.h > mit ein

# schließt sie "Vertex_Node.h" mit ein

//Construction/Destruction

Vertex_Node::Vertex_Node(Gen_Data_Ptr The_Attribute)

{

Arc_List_Ptr = neues Arc_List;

Next_Vertex = 0;

Reference_Count = 0;

Vertex_Attribute = The_Attribute;

}

Vertex_Node::~Vertex_Node()

{

}

//Sichtbarmachung des einzelnen Namens der Spitze

Lücke Vertex_Node::Display_Vertex()

{

Vertex_Attribute->Display();

if(Next_Vertex! = 0)

cout < < ",";

sonst

cout < < endl;

}

//Visualizzazione des Namens der Spitze von Bögen von ihm abgehend und von ihrem Sie betreffen uns des Bestimmungsortes

Lücke Vertex_Node::Display_Vertex_And_Arcs()

{

"\nVertice" cout < <;

Vertex_Attribute->Display();

cout < < "\n\tArchi Hereinkommen: "< < Reference_Count;

cout < < "\n\tArchi uscenti: ";

Arc_List_Ptr->Display_Arcs();

}

Bis zu dem Erbauer beachten sich Sie daß an zweiter Stelle, wieviel verlangt vom SICHTC die 5.0 gunlayers direkt inizializzati bis 0 kommt und nicht zur NULL wie geschieht in anderen Sprachen oder in vorhergehenden Versionen. Außerdem fangen die Initialisierung von ARC_LIST_PTR geschieht direkt verlangend dem Betriebssystemgedächtnis für einen Gegenstand der Art ARC_LIST auf, der genau von ARC_LIST_PTR gezielt wird.

Es gibt zwei verschiedene Funktionen der Sichtbarmachung definiert auf einem VERTEX_NODE, bevor die Anzeige Methode des Kategorie ELEMENTS alleine das die Spitze Zurückrufen und seine Ableitungen sichtbar macht, während zweite auch Bogen es abgehend mit der Display_Arcs Methode sichtbar macht, die auf Art ARC_LIST definiert wird.

DIAGRAMM (Vertex_List)

//Graph.h: Schnittstelle für die Diagrammkategorie.

# if!defined(AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Arc_List.h" mit ein

# schließt es "Arc_Node.h" mit ein

klassifizieren Sie Diagramm //class, das die Liste von Ihnen Interesse zu uns einführt

{

Freundkategorie Vertex_Node;

geschützt:

Vertex_Node * Kopf; //tip immer zum Kopf der Liste

Öffentlichkeit:

internes Number_Of_Arcs_In();

leeres Clear();

bool Remove_Arc(Gen_Data_Ptr Source_Vertex, Gen_Data_Ptr Dest_Vertex, Gen_Data_Ptr The_Arc);

leeres Display_Graph();

bool Create_An_Arc(Gen_Data_Ptr Source_Vertex, Gen_Data_Ptr Dest_Vertex,

Gen_Data_Ptr The_Attribute);

Vertex_Node * Is_Member_Of(Gen_Data_Ptr The_Attribute);

internes Number_Of_Vertices_In();

bool Remove_Vertex(Gen_Data_Ptr The_Source);

leeres Display_Only_Vertex();

leeres Insert(Gen_Data_Ptr The_Attribute);

Graph();

virtuelles ~Graph();

};

# endif / /!defined(AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _)

Auch in diesem Fall folglich, da sie für das ARC_LIST geschehen war, sind die einzigen privaten Daten das gunlayer zum ersten VERTEX_NODE, das die Liste betrifft und im allgemeinen Teil erscheinen die Betriebe eseguibili Standards auf einer Liste.

//Graph.cpp: Implementierung der Diagrammkategorie.

# schließt sie < iostream.h > mit ein

# schließt sie "Graph.h" mit ein

# schließt sie "Vertex_Node.h" mit ein

//Construction/Destruction

Graph::Graph()

{

Kopf = 0;

}

Graph::~Graph()

{

}

//Inserisce, das eine Spitze im Kopf zur Liste von Ihnen zu uns steuernd betreffen, daß sie nicht bereits in anwesend ist, welcher Fall nicht Verdopplung geschieht.

leeres Graph::Insert(Gen_Data_Ptr The_Attribute)

{

if(Is_Member_Of(The_Attribute))

{

cerr < < "die Spitze ist bereits anwesend im Diagramm." < < endl;

Rückkehr;

}

Vertex_Node * Vertex_Node_Ptr;

//Vertex_Node_Ptr Spitze zu einem neuen Vertex_Node

Vertex_Node_Ptr = neues Vertex_Node(The_Attribute);

//places im Kopf zur Liste die neue Spitze

if(!Head)

{// LEERE LISTE

Kopf = Vertex_Node_Ptr;

Vertex_Node_Ptr->Next_Vertex = 0;

}

sonst

{// NICHT LEERE LISTE

Vertex_Node_Ptr->Next_Vertex = Kopf;

Kopf = Vertex_Node_Ptr;

}

//Visualizza, welches die einzelnen Attribute von Ihnen zu uns betreffen.

Lücke Graph::Display_Only_Vertex()

{

if(Head == 0)

{

cout < < "nicht Gipfel in diesem Diagramm" < < endl;

}

sonst

{

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

while(Vertex_Node_Ptr! = 0)

{

//der Zyklus ist wiederholte Sünde, wenn sie nicht UNGÜLTIG ist

Vertex_Node_Ptr->Display_Vertex();

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

//Rimozione einer einzelnen Spitze und seiner Bögen vom Diagramm previo eine Steuerung, daß die Spitze nicht Bestimmungsort irgendeines Bogens ist.

bool Graph::Remove_Vertex(Gen_Data_Ptr Vertex_To_Remove)

{// Punkt ein gunlayer zum Kopf der Liste

Vertex_Node * Vertex_Node_Ptr_1;

Vertex_Node * Vertex_Node_Ptr_2;

Vertex_Node_Ptr_1 = Kopf;

Vertex_Node_Ptr_2 = Kopf;

//search des zu entfernen Nullpunktes

while((Vertex_Node_Ptr_1! = 0) &&

(!(Vertex_To_Remove->Is_Equal(Vertex_Node_Ptr_1->Vertex_Attribute))))

{

Vertex_Node_Ptr_2 = Vertex_Node_Ptr_1;

Vertex_Node_Ptr_1 = Vertex_Node_Ptr_1->Next_Vertex;

}

//Steuerung, daß die Spitze besteht und daß sie nicht von irgendeinem Bogen vorangegangen wird

if((Vertex_Node_Ptr_1! = 0)&&

((Vertex_Node_Ptr_1->Reference_Count == 0) ||

(&& (Vertex_Node_Ptr_1->Reference_Count!=0)

(!(Vertex_To_Remove->Is_Equal(Vertex_Node_Ptr_1->Vertex_Attribute))))))

{

//Gatter alle Bögen zu ihm abgehend von der Spitze

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Vertex_Node_Ptr_1->Arc_List_Ptr->Arc_List_Head;

while(Arc_Node_Ptr! = 0)

{// der Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Remove_Arc(Vertex_To_Remove, Arc_Node_Ptr->Arc_Destination,

Arc_Node_Ptr->Arc_Attribute);

Arc_Node_Ptr = Vertex_Node_Ptr_1->Arc_List_Ptr->Arc_List_Head;

}

//I HABEN das ELEMENT GEFUNDEN, UM ZU ENTFERNEN

if(Vertex_Node_Ptr_1! = Kopf)

Vertex_Node_Ptr_2->Next_Vertex = Vertex_Node_Ptr_1->Next_Vertex;

der sonst ZU ENTFERNEN //the BOGEN ist der ERSTE der LISTE

Kopf = Kopf->Next_Vertex;

//I beseitigen das vertice

Löschung Vertex_Node_Ptr_1;

Rückhol richten Sie aus;

};

if(Vertex_Node_Ptr_1 == 0)

{

cerr < < "die zu beseitigen Spitze ist nicht" < < endl gefunden worden;

}

sonst

{

cerr < < "die Spitze ist nicht dismissable in, wieviel Bestimmungsortes";

cerr < < Vertex_Node_Ptr_1->Reference_Count < < "Bögen." < < endl;

}

Rückholfalsches;

}

//determination der Zahl von Ihnen betreffen uns von, welchem das Diagramm gebildet wird.

internes Graph::Number_Of_Vertices_In()

{

internes N_Vertex = 0;

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

while(Vertex_Node_Ptr! = 0)

{ //the Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

N_Vertex;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

Rückholn_Vertex;

}

//Determination, wenn die Spitze oder kleiner dem Diagramm mit Zurückerstattung des gunlayer der gleichen Spitze im Fall gehört

//it kommt gekennzeichnet, andernfalls kommt es das gunlayer zurück gegeben, das Liste 0 schließt, die ist und folglich gibt die Funktion zurück

//FALSE, wenn die Spitze nicht gekennzeichnet kommt.

Vertex_Node * Graph::Is_Member_Of(Gen_Data_Ptr The_Attribute)

{

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

while((Vertex_Node_Ptr! = 0) &&

!(The_Attribute->Is_Equal(Vertex_Node_Ptr->Vertex_Attribute)))

{

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

Rückholvertex_Node_Ptr;

}

//Questa Mitgliedsfunktion führt die Kreation einer Bogen previo Steuerung des Bestehens der Spitze Quelle und des Bestimmungsortes durch

bool Graph::Create_An_Arc(Gen_Data_Ptr Source_Vertex, Gen_Data_Ptr Dest_Vertex, Gen_Data_Ptr The_Attribute)

{

Vertex_Node * Source_Vertex_Ptr;

Source_Vertex_Ptr = Is_Member_Of(Source_Vertex);

if(Source_Vertex_Ptr == 0)

{

cerr < < "die Spitze Quelle ist inesistente\n";

Rückholfalsches;

}

Vertex_Node * Dest_Vertex_Ptr;

Dest_Vertex_Ptr = Is_Member_Of(Dest_Vertex);

if(Dest_Vertex_Ptr == 0)

{

cerr < < "die Bestimmungsortspitze ist inesistente\n";

Rückholfalsches;

}

//Increment der Bezugszählimpuls des Bestimmungsortbogens

Dest_Vertex_Ptr->Reference_Count;

//Creation des Bogens

Source_Vertex_Ptr->Arc_List_Ptr->Insert(The_Attribute, Dest_Vertex);

Rückhol richten Sie aus;

}

//Visualizzazione aller Nullpunkte und aller Bögen es betreffend das Diagramm.

Lücke Graph::Display_Graph()

{

if(Head == 0)

{

cout < < "nicht Gipfel in diesem Diagramm" < < endl < < endl;

}

sonst

{

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

while(Vertex_Node_Ptr! = 0)

{ //the Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Vertex_Node_Ptr->Display_Vertex_And_Arcs();

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

//Rimozione einer Datenbogen previo Steuerung des Bestehens von dem gleichen. Die Funktion führt auch durch

//the Verminderung des REFERENCE_COUNT der Spitze des Bestimmungsortes vom Bogen.

bool Graph::Remove_Arc(Gen_Data_Ptr Source_Vertex, Gen_Data_Ptr Dest_Vertex, Gen_Data_Ptr The_Arc)

{

//control, daß die Spitze Quelle besteht

Vertex_Node * Source_Vertex_Ptr;

Source_Vertex_Ptr = Is_Member_Of(Source_Vertex);

if(Source_Vertex_Ptr == 0)

{

cerr < < "\nIl Spitze Quelle ist nicht vorhanden";

//monster, welches die Liste von Ihnen zu uns betreffen

Display_Only_Vertex();

Rückholfalsches;

}

Vertex_Node * Dest_Vertex_Ptr;

Dest_Vertex_Ptr = Is_Member_Of(Dest_Vertex);

if(Dest_Vertex_Ptr == 0)

{

cerr < < "\nIl Bestimmungsortspitze ist nicht vorhanden";

Source_Vertex_Ptr->Display_Vertex_And_Arcs();

Rückholfalsches;

}

Arc_Node * Arc_Node_Ptr;

Arc_Node_Ptr = Source_Vertex_Ptr->Arc_List_Ptr->Is_Member_Of(The_Arc, Dest_Vertex);

if(Arc_Node_Ptr == 0)

{

cerr < < "\nL ' zu beseitigen der Bogen ist nicht vorhanden";

Source_Vertex_Ptr->Display_Vertex_And_Arcs();

Rückholfalsches;

}

sonst

{

Source_Vertex_Ptr->Arc_List_Ptr->Remove(The_Arc, Dest_Vertex);

Dest_Vertex_Ptr->Reference_Count --;

Rückhol richten Sie aus;

}

//Eliminazione aller Bögen zu ihm und der aller Sie betreffen uns betreffend das Diagramm, dieses für Kompatibilität mit der Steuerung von

//Reference_Count geschieht sie, daß vorher beseitigend von den jede Spitze Bögen zu ihr abgehend und alle dann, beseitigend, Sie zu uns betreffen.

Lücke Graph::Clear()

{

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

//Removal der Bögen von allen Interessen zu uns

while(Vertex_Node_Ptr! = 0)

{ //the Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Vertex_Node_Ptr->Arc_List_Ptr->Clear();

Vertex_Node_Ptr->Reference_Count = 0;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

//Removal von Ihnen Interesse zu uns

Vertex_Node_Ptr = Kopf;

while(Vertex_Node_Ptr! = 0)

{ //the Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

Remove_Vertex(Vertex_Node_Ptr->Vertex_Attribute);

Vertex_Node_Ptr = Kopf;

}

//Calculation der Zahl den Bögen, die im Diagramm vorhanden sind, erreichte das Anwenden an jeder Spitze des omonima

//function definiert für das ARC_LIST.

internes Graph::Number_Of_Arcs_In()

{

internes N_Arcs = 0;

Vertex_Node * Vertex_Node_Ptr;

Vertex_Node_Ptr = Kopf;

while(Vertex_Node_Ptr! = 0)

{ //the Zyklus ist wiederholte Sünde, wenn er nicht UNGÜLTIG ist

N_Arcs = N_Arcs (Vertex_Node_Ptr->Arc_List_Ptr->Number_Of_Arcs_In());

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex;

}

Rückholn_Arcs;

}

B) Beschreibung und Implementierung des polimorfismo

Mit dem Bezeichnung polimorfismo bedeuten wir die Fähigkeit zu einer Kategorie Unterseite, von den Funktionen, die neu definiert von den abgeleiteten Kategorien kommen, und von der Möglichkeit des Compilers zu definieren, zum der späten Schwergängigkeit durchzuführen, daß Sie die Methode für die gerechte Kategorie erinnern an, die mittels einer Steuerung auf dem zurückrufenden Gegenstand die Funktion abgeleitet wird. Möglicherweise in solchem Kontext, den die sinnvollere Anwendung dieses von uns gerecht ist, führte ein, das die, um ist für jede Funktion zu schreiben zu vermeiden Möglichkeit, andere n arbeitet, um n mögliche Arten von Daten einzuführen.

Die Lösung besteht, wenn sie eine abstrakte Kategorie, die aufstellt ELEMENT, von der reale Kategorien n zu den verschiedenen Arten von Daten n Verwandten ableiten, in unserem Fall eingeführtes FLOAT_OBJ gewesen sind, INT_OBJ und CHAR_OBJ, ognuna di.le, die den Erbauer neu definieren, die Anzeige Funktion und Funktion IS_EQUAL nachher beschrieben.

ELEMENT

//Element.h: Schnittstelle für die Elementkategorie.

# if!defined(AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

typedef Putzfrau Class_Name[20 ];

# schließt es < string.h > mit ein

Kategorie Element

{

Öffentlichkeit:

virtuelles bool Is_Equal(Element * Element_Ptr);

virtuelles leeres Display();

Putzfrau * Get_Class();

Element();

virtuelles ~Element();

geschützt:

Class_Name My_Class;

};

typedef Element * Gen_Data_Ptr; //defines ein gunlayer zur Elementkategorie

# endif / /!defined(AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _)

Diese Kategorie hat wie die nur Daten, die und folglich ereditabile vor den abgeleiteten Kategorien der Name der Kategorie, Informationen geschützt werden, die nützliches laddove eines Datengegenstandes müssen feststellen sind, welches Kategorie gehört ableitete und wenn es von einem gunlayer zum Kategorie Mutter-ELEMENT gezielt wird.

Sie kommt definierte außerdem ein gunlayer zu dieser Kategorie, die dann in allen Funktionen benutzt wird, die ELEMENT.H importieren, um ein gunlayer zu einer Art generische Daten zu kennzeichnen.

Die Erklärung der Funktionen Öffentlichkeit ist folgend:

//Element.cpp: Implementierung der Elementkategorie.

# schließt sie "Element.h" mit ein

//Construction/Destruction

Element::Element()

{

strcpy(My_Class, "Element");

}

Element::~Element()

{

}

//Returns der Name der Kategorie

Putzfrau * Element::Get_Class()

{

Rückholmy_Class;

}

//Questa Funktion wird von den abgeleiteten Kategorien neu definiert.

Lücke Element::Display()

{

}

//Questa Funktion ist virtuell und folglich neu definiert von den abgeleiteten Kategorien, mach's gut sie selbst, um die Gleichheit der Daten herzustellen

//della Kategorie, die sie kommt, wendete die Methode mit der Kategorie an, die vom gunlayer gezielt wurde, das im Einkommen empfangen wird.

bool Element::Is_Equal(Element * Element_Ptr)

{

Rückholfalsches;

}

Wir sehen Stunde, während die abgeleiteten Kategorien die Funktionen neu definieren, die vom Kategorie ELEMENT virtuell sind:

INT_OBJ

//Int_Obj.h: Schnittstelle für die Int_Obj Kategorie.

# if!defined(AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Element.h" mit ein

Kategorie Int_Obj: allgemeines Element

{

Öffentlichkeit:

leeres Display();

bool Is_Equal(Element * Element_Ptr);

internes Get_Val();

Int_Obj();

Int_Obj(int Int_Data);

virtuelles ~Int_Obj();

geschützt:

interner Wert;

};

# endif / /!defined(AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _)

In diesem Fall sind die einzigen geschützten Daten Wert, den es zugängliches Solo von der Int_Obj Kategorie ist und sie der Kategorie Mutter nicht geben, die sie auferlegt, die, selbst wenn der Code der Anzeige für alle und die 3 abgeleiteten Kategorien gleich ist, solcher Code nicht in der Kategorie Unterseite implementabile ist.

Die entsprechende Erklärung ist folgend:

//Int_Obj.cpp: Implementierung der Int_Obj Kategorie.

# schließt sie < iostream.h > mit ein

# schließt sie "Int_Obj.h" mit ein

//Construction/Destruction

Int_Obj::Int_Obj()

{

strcpy(My_Class, "Int_Obj");

}

Int_Obj::~Int_Obj()

{

}

//inizializzatore Erbauer

Int_Obj::Int_Obj(int Int_Data)

{

strcpy(My_Class, "Int_Obj");

Wert = Int_Data;

}

//Get_Val

Int_Obj::Get_Val()

{

Rückholwert;

}

//Anzeige

Lücke Int_Obj::Display()

{

cout < < Wert;

}

//IS_EQUAL

//Questa Funktion stimmt überein, zu überprüfen, ob der Wert des Gegenstandes, für den es zurückgerufen wird, dem Wert gleich ist

//della Gegenstand der Art ELEMENT, den sie im Einkommen empfängt. Ci² geschieht previa Umwandlung des gunlayer

//ELEMENT in einem gunlayer zu INT_OBJ.

bool Int_Obj::Is_Equal(Element * Element_Ptr)

{

//the strcmp gibt zurück 0, wenn das stringhe 2 sie gleich sind

if(strcmp(Element_Ptr->Get_Class(), "Int_Obj"))

Rückholfalsches;

sonst

{

//wandele ich das generische gunlayer in einem gunlayer in gesamtes um

Int_Obj * Int_Obj_Ptr = (Int_Obj *)Element_Ptr;

//comparison, welches die Daten zu Ihnen von den 2 gunlayers vorangehen

return(Get_Val()==(Int_Obj_Ptr->Get_Val()));

}

CHAR_OBJ

//Char_Obj.h: Schnittstelle für die Char_Obj Kategorie.

# if!defined(AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Element.h" mit ein

Kategorie Char_Obj: allgemeines Element

{

geschützt:

Putzfrau Wert;

Öffentlichkeit:

Char_Obj();

Char_Obj(char Char_Data);

virtuelles ~Char_Obj();

leeres Display();

bool Is_Equal(Element * Element_Ptr);

Putzfrau Get_Val();

};

# endif / /!defined(AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _)

Die entsprechende Erklärung ist folgend:

//Char_Obj.cpp: Implementierung der Char_Obj Kategorie.

# schließt sie "har_Obj.h" mit ein

# schließt sie < iostream.h > mit ein

//Construction/Destruction

Char_Obj::Char_Obj()

{

strcpy(My_Class, "Char_Obj");

}

//inizializzatore Erbauer

Char_Obj::Char_Obj(char Char_Data)

{

strcpy(My_Class, "Char_Obj");

Wert = Char_Data;

}

Char_Obj::~Char_Obj()

{

}

//GET_VAL

Putzfrau Char_Obj::Get_Val()

{

Rückholwert;

}

bool Char_Obj::Is_Equal(Element * Element_Ptr)

{

//the strcmp gibt zurück 0, wenn das stringhe 2 sie gleich sind

if(strcmp(Element_Ptr->Get_Class(), "Char_Obj"))

Rückholfalsches;

sonst

{

//wandele ich das generische gunlayer in einem gunlayer um

//to gesamt

Char_Obj * Char_Obj_Ptr = (Char_Obj *)Element_Ptr;

//comparison, welches die Daten zu Ihnen von den 2 gunlayers vorangehen

return(Get_Val()==(Char_Obj_Ptr->Get_Val()));

}

//Anzeige

Lücke Char_Obj::Display()

{

cout < < Wert;

}

FLOAT_OBJ

//Float_Obj.h: Schnittstelle für die Float_Obj Kategorie.

# if!defined(AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _)

# definieren Sie AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _

# wenn _ MSC_VER > = 1000

# Pragmaunzen

# endif //_ MSC_VER > = 1000

# schließt es "Element.h" mit ein

Kategorie Float_Obj: allgemeines Element

{

Öffentlichkeit:

Float_Obj();

Float_Obj(float Float_Data);

virtuelles ~Float_Obj();

leeres Display();

bool Is_Equal(Element * Element_Ptr);

Hin- und Herbewegung Get_Val();

geschützt:

Hin- und Herbewegung Wert;

};

# endif / /!defined(AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _)

Die Erklärung der Kategorie FLOAT_OBJ ist folgend:

//Float_Obj.cpp: Implementierung der Float_Obj Kategorie.

# schließt sie < iostream.h > mit ein

# schließt sie "Float_Obj.h" mit ein

//Construction/Destruction

Float_Obj::Float_Obj()

{

strcpy(My_Class, "Float_Obj");

}

Float_Obj::~Float_Obj()

{

}

//inizializzatore Erbauer

Float_Obj::Float_Obj(float Float_Data)

{

strcpy(My_Class, "Float_Obj");

Wert = Float_Data;

}

//GET_VAL

Hin- und Herbewegung Float_Obj::Get_Val()

{

Rückholwert;

}

//IS_EQUAL

bool Float_Obj::Is_Equal(Element * Element_Ptr)

{

//the strcmp gibt zurück 0, wenn das stringhe 2 sie gleich sind

if(strcmp(Element_Ptr->Get_Class(), "Float_Obj"))

Rückholfalsches;

sonst

{

//I Bekehrter das generische gunlayer in einem gunlayer zu Float_Obj

Float_Obj * Float_Obj_Ptr = (Float_Obj *)Element_Ptr;

//comparison, welches die Daten zu Ihnen von den 2 gunlayers vorangehen

return(Get_Val()==(Float_Obj_Ptr->Get_Val()));

}

//ANZEIGE

Lücke Float_Obj::Display()

{

cout < < Wert;

}

Während diese Kategorien benutzt werden können, um ein Diagramm mit Bogen einzuführen und Haben zu betreffen, teilen Attribute zu uns von welche Art zwischen dieser Stunde definiert im folgenden veranschaulicht werden in Paragraphen ein.

c) applicativo Entwicklung basiert auf Kategorie DIAGRAMM

Applicativo das Folgen wird von der Anforderung zu sehen, um das Mitglied, welches die Funktion, die für die Diagrammkategorie folglich definiert wird, um begrenzt wird ein Menü der eseguibili Betriebe auf dem gleichen aufzustellen, zum ognuna di.le zu bearbeiten getragen, das eine Funktion daß verbunden ist, das notwendige laddove, Versorgungsmaterialien, zum Kunden der Einkommendaten, die zum eempio die Attribute für den Bogen oder zur Spitze des Bestimmungsortes oder der Spitze Quelle zu verlangen. Die Type_Selection Funktion ist außerdem Geschenk, deren für jeder des Fallüberschusses zu Ihnen übereinstimmt mit dem Kunden, einzusetzen tipologia, da es Einsatz zustimmt, solche Funktion bildet nicht andere unterstreicht, die zum istanziare der gerechte Gegenstand zwischen FLOAT_OBJ, CHAR_OBJ und INT_OBJ und dem Bilden gehen, um es von einem der gunlayers zum Haben des allgemeinen ossia Source_Name_Ptr zu zielen Sicht des Kategorie ELEMENTS, Dest_Name_Ptr ED Arc_Name_Ptr.

# schließt sie "Graph.h" mit ein

# schließt sie "Arc_List.h" mit ein

# schließt sie "Element.h" mit ein

# schließt sie "Int_Obj.h" mit ein

# schließt sie "har_Obj.h" mit ein

# schließt sie "Float_Obj.h" mit ein

# schließt sie < ctype.h > mit ein

# schließt sie < string.h > mit ein

# schließt sie < iostream.h > mit ein

# schließt sie < conio.h > mit ein

//MANIPULATING DES GRAFO

leeres Insert();

leeres Create();

leeres Display();

leeres Number_Of_Vertices_In();

leeres Number_Of_Arcs_In();

leeres rechtes y_Arc();

leeres rechtes y_Vertex();

leeres rechtes y_Graph();

//PER DAS POLIMORFISMO

Putzfrau Type_Selection();

leeres Set_Arc_Name();

leeres Set_Source_Vertex_Name();

leeres Set_Dest_Vertex_Name();

Element * Source_Name_Ptr, * Dest_Name_Ptr, * Arc_Name_Ptr;

Diagramm * My_Graph;

leeres main()

{

cout<<"\n\n";

cout<< "____________________________________________________________ \n";

cout<< " | |\n ";

cout<< " | - PROGRAMM Des MANAGEMENTS Eines ORIENTIERTEN GRAFO - |\n ";

cout<< " |____________________________________________________________ |\n ";

cout<< " | * Version 1.0 * |\n ";

cout<< " | **************** |\n ";

cout<< " | |\n ";

cout<< " | Programmierer: |\n ";

cout<< " | ------------ |\n ";

cout<< " | |\n ";

cout<< " | IANNONE ALESSIO KRICKET GIANLUCA D`OTTAVIO ANTONIO |\n ";

cout<< " | |\n ";

cout<< " |__________________________________________________________ __|\n ";

Putzfrauantwort;

cin > > Antwort;

cout < < "\n\n\n\n\n\n\n\n\n\n\n\n";

bool wieder;

My_Graph = neues Diagramm;

Ich gebe

{

cout<<"\n";

cout < < "************************************************************ \n";

cout < < "* Prego zum Vorwählen eine der folgenden Wahlen: * \n ";

cout < < "* 1) Einfügung von vertice a * \n";

cout < < "* 2) Einfügung von arco a * \n";

cout < < "* 3) Visualizzazione * \n";

cout < < "* 4) Ermittlung der Zahl von vertici * \n";

cout < < "* 5) Ermittlung der Zahl von archi * \n";

cout < < "* 6) Beseitigung von arco a * \n";

cout < < "* 7) Beseitigung von vertice a * \n";

cout < < "* 8) Beseitigung von Diagramm a * \n";

cout < < "* 0) Geldstrafe * \n";

cout < < "************************************************************* \n";

cin > > Antwort;

cout<<"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";

switch(response)

{

Häuser ' 1 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Einfügung von vertice a * \n";

cout < < "\t\t\t**********************************\n\n";

Insert();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 2 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Einfügung von arco a * \n";

cout < < "\t\t\t**********************************\n\n";

Create();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 3 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Sichtbarmachung des Diagramms * \n";

cout < < "\t\t\t**********************************\n\n";

Display();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 4 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Ermittlung des n von vertici * \n";

cout < < "\t\t\t**********************************\n\n";

Number_Of_Vertices_In();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 5 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Ermittlung des n der Bögen * \n";

cout < < "\t\t\t**********************************\n\n";

Number_Of_Arcs_In();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 6 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Beseitigung von arco a * \n";

cout < < "\t\t\t**********************************\n\n";

Rechtes y_Arc();

wieder = richten Sie aus;

fahren Sie fort;

Häuser ' 7 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Beseitigung von vertice a * \n";

cout < < "\t\t\t**********************************\n\n";

Rechtes y_Vertex();

wieder = richten Sie aus;

ununterbrochen;

Häuser ' 8 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * Beseitigung des Diagramms * \n";

cout < < "\t\t\t**********************************\n\n";

Rechtes y_Graph();

wieder = richten Sie aus;

ununterbrochen;

Häuser ' 0 ':

cout < < "\t\t\t**********************************\n";

cout < < "\t\t\t * sehen Sie Sie...... * \n";

cout < < "\t\t\t**********************************\n\n";

wieder = falsch;

ununterbrochen;

Rückstellung:

wieder = richten Sie aus;

ununterbrochen;

Geldstrafe}// des Schalters

Geldstrafe } //of, das ich gebe

while(again);

}

//Inserzione einer Spitze im Diagramm

leeres Insert()

{

Set_Source_Vertex_Name();

My_Graph->Insert(Source_Name_Ptr);

}

//Creazione eines Bogens

leeres Create()

{

Set_Source_Vertex_Name();

Set_Dest_Vertex_Name();

Set_Arc_Name();

My_Graph->Create_An_Arc(Source_Name_Ptr, Dest_Name_Ptr, Arc_Name_Ptr);

}

//Visualizzazione des Diagramms

leeres Display()

{

My_Graph->Display_Graph();

}

//Visualizzazione der Zahl von Ihnen betreffen zu uns anwesend im Diagramm

leeres Number_Of_Vertices_In()

{

cout < < "im Diagramm ist anwesend";

cout < < My_Graph->Number_Of_Vertices_In();

cout < < "Sie betreffen zu uns." < < endl;

}

//Visualizzazione der Zahl Bögen stellen sich im Diagramm dar

leeres Number_Of_Arcs_In()

{

cout < < "im Diagramm ist anwesend";

cout < < My_Graph->Number_Of_Arcs_In();

cout < < "Bögen." < < endl;

}

//Eliminazione eines Bogens vom Diagramm

leeres rechtes y_Arc()

{

Set_Source_Vertex_Name();

Set_Dest_Vertex_Name();

Set_Arc_Name();

My_Graph->Remove_Arc(Source_Name_Ptr, Dest_Name_Ptr, Arc_Name_Ptr);

}

//Eliminazione einer Spitze vom Diagramm

leeres rechtes y_Vertex()

{

Set_Source_Vertex_Name();

My_Graph->Remove_Vertex(Source_Name_Ptr);

}

//Eliminazione des Diagramms

leeres rechtes y_Graph()

{

My_Graph->Clear();

}

//Visualizzazione von abgeschirmten der Vorwähler der Art von Daten

Putzfrau Type_Selection()

{

Putzfrau Data_Type;

cout < < "\t***************************************************************\n";

cout < < "\t *c) Putzfrau -128 bis 127 * \n";

cout < < "\t * F) Hin- und Herbewegung 3.4*(10**-38) bis 3.4*(10 ** 38) * \n";

cout < < "\t * I) internes -2.147.483.648 bis 2.147.483.647 * \n";

cout < < "\t***************************************************************\n";

cin > > Data_Type;

Rückkehr (toupper(Data_Type));

}

//Questa Verfahren zielt Source_Name_Ptr zur Adresse des Gegenstandes dieser istanzia Angestellte selbst

//this dauern ein von der Art der vorgewählten Daten

leeres Set_Source_Vertex_Name()

{

bool wieder;

cout < < "die Art von Daten für die Spitze sorgente:\n\n vorwählen";

Ich gebe

{

switch(Type_Selection())

{

Häuser ' dort:

Putzfrau Char_Data;

cout < < "Immettere das Attribut (Putzfrau): ";

cin > > Char_Data;

Source_Name_Ptr = neues Char_Obj(Char_Data);

wieder = falsch;

ununterbrochen;

Häuser ' I':

internes Int_Data;

cout < < "Immettere das Attribut (langes internes): ";

cin > > Int_Data;

Source_Name_Ptr = neues Int_Obj(Int_Data);

wieder = falsch;

ununterbrochen;

Häuser ' F ':

Hin- und Herbewegung Float_Data;

cout < < "Immettere das Attribut (Hin- und Herbewegung): ";

cin > > Float_Data;

Source_Name_Ptr = neues Float_Obj(Float_Data);

wieder = falsch;

ununterbrochen;

Rückstellung:

wieder = richten Sie aus;

cout < < "\n\n\n\n\n\n\n\n\n\n\n\n";

ununterbrochen;

}

}while(again == zutreffend);

cout < < "\n\n\n\n\n\n";

}

//Questa Verfahren zielt Dest_Name_Ptr zur Adresse des Gegenstandes dieser istanzia Angestellte selbst

//this dauern ein von der Art der vorgewählten Daten

leeres Set_Dest_Vertex_Name()

{

bool wieder;

cout < < "die Art von Daten für die Spitze von destinazione:\n\n vorwählen";

Ich gebe

{

switch(Type_Selection())

{

Häuser ' dort:

Putzfrau Char_Data;

cout < < "Immettere das Attribut (Putzfrau): ";

cin > > Char_Data;

Dest_Name_Ptr = neues Char_Obj(Char_Data);

wieder = falsch;

ununterbrochen;

Häuser ' I':

internes Int_Data;

cout < < "Immettere das Attribut (langes internes): ";

cin > > Int_Data;

Dest_Name_Ptr = neues Int_Obj(Int_Data);

wieder = falsch;

ununterbrochen;

Häuser ' F ':

Hin- und Herbewegung Float_Data;

cout < < "Immettere das Attribut (Hin- und Herbewegung): ";

cin > > Float_Data;

Dest_Name_Ptr = neues Float_Obj(Float_Data);

wieder = falsch;

ununterbrochen;

Rückstellung:

wieder = richten Sie aus;

ununterbrochen;

}

}while(again == zutreffend);

cout < < "\n\n\n\n\n\n";

}

//Questa Verfahren zielt Arc_Name_Ptr zur Adresse des Gegenstandes dieser istanzia Angestellte selbst

//this dauern ein von der Art der vorgewählten Daten

leeres Set_Arc_Name()

{

bool wieder;

cout < < "die Art von Daten für das arc:\n\n vorwählen";

Ich gebe

{

switch(Type_Selection())

{

Häuser ' dort:

Putzfrau Char_Data;

cout < < "Immettere das Attribut (Putzfrau): ";

cin > > Char_Data;

Arc_Name_Ptr = neues Char_Obj(Char_Data);

wieder = falsch;

ununterbrochen;

Häuser ' I':

internes Int_Data;

cout < < "Immettere das Attribut (langes internes): ";

cin > > Int_Data;

Arc_Name_Ptr = neues Int_Obj(Int_Data);

wieder = falsch;

ununterbrochen;

Häuser ' F ':

Hin- und Herbewegung Float_Data;

cout < < "Immettere das Attribut (Hin- und Herbewegung): ";

cin > > Float_Data;

Arc_Name_Ptr = neues Float_Obj(Float_Data);

wieder = falsch;

ununterbrochen;

Rückstellung:

wieder = richten Sie aus;

ununterbrochen;

}

}while(again == zutreffend);

cout < < "\n\n\n\n\n\n";

}