Grafi Oriente À Vous

Le premier témoignage de l'emploi du grafi les a ries à 1736 où Leonhard Euler les a employées afin de résoudre le problème classique des ponts de Koenigsberg où le fleuve de Pregal glisse autour de l'île de Kneiphof. Il y a quatre terres fermes identifiées des lettres à, B, C, D sur le schéma 1, qu'ils ont ce fleuve à leurs frontières. Sept ponts identifient à vous des lettres agissent, relient quatre terres fermes. Le problème du pont de Koenigsberg est suivant : partant d'une terre ferme, il est possible de retourner à l'iniziale de position ensuite pour avoir croisé chaque seule heure du pont un ?

Une manière possible est suivante :

· Pour partir de la terre ferme B

· Pour croiser le pont à dans l'ordre attrapant vers le haut de l'île à

· Pour utiliser le pont et afin de rattraper la région de D

· Pour utiliser le pont g afin de rattraper le secteur C

· Pour utiliser le pont d afin de rattraper le secteur à

· Pour utiliser le pont b afin de rattraper la région de B

· Pour utiliser le pont f afin de rattraper la région de D

Cette distance ne croise pas tous les ponts ni l'un ni l'autre mène à la position du départ Euler de B. a découvert que les gens de Koenigsberg ne peuvent pas croiser chaque seule heure du pont un et retourner dans la position de départ. Euler a résolu le problème en utilisant le graphique (un multigraphe dans les effets) dans lequel les terres fermes qu'ils étaient vous souci ( ou des noeuds à nous ) et les ponts étaient les côtés ( voûte ). Sa solution est non seulement élégante mais elle s'applique à tout le grafi.

Euler a défini le degré d'un apex comme le nombre d'incidents de côtés là-dessus, démontré également qu'une distance existe ce congé d'un apex celui qui, croise un seul temps chaque côté et les finitions dans l'apex les commence seulement, si et si le degré de chaque apex est égal. Une distance semblable s'appellera couverte d'Euler. Cette distance n'existe pas pour les ponts de Koenigsberg, dans combien tous les soucis coûte de degré inégal.

De cette première application, le grafi a été des utilisations dans une immense gamme vous des applications, comme l'analyse des ouvriers électriques de circuits, la planification des plans, l'identification des composés de produit chimique ou la détermination des routes plus courtes.

2) définitions

Un graphique c'est une collection qui comporte deux ensembles, un de vous souci à nous et une de voûtes, alors qu'avec que d'elle les voûtes peuvent lui sont vides, avec des soucis à nous, si le graphique il existe, pu² pour ne pas s'avérer vide. Un apex également s'appelle le noeud et constitue la base structurale d'élément du graphique. Un arc est l'ouverture entre deux soucis à nous, si elle que les voûtes il du graphique sont oriente à vous, alors est parlée au sujet du graphique orienté autrement est parlée au sujet du graphique non orienté.

À chaque apex et arc elles peuvent être associées des étiquettes, si cela se produit est parlée au sujet du graphique marqué dans les soucis nous ou dans lui les voûtes, les deux voûtes d'étiquettes, pas nécessairement doivent être diverses, est possible pour avoir deux voûtes avec le même attribut. Dans le cas dans lequel les étiquettes elles sont constituées à partir des nombres entiers ou déciment eux et les éléments du graphique qu'elles sont marquées de la manière commandée, puis sont parlées au sujet du graphique pesé.

Au orienté à l'intérieur de d'un graphique, la manière est définie un ordre des soucis à nous tels qu'existe un arc entre chaque apex et que le successif. La longueur de la manière égale e 'au nombre de voûtes qu'ils vous relient souci à nous. Un apex simple constituera une manière de la longueur zéro. La manière indique simple si, à l'intérieur de la manière, elles n'existent pas que vous le souci à nous qu'elles apparaissent plus d'une fois, dans le cas contraire est non simple. Dans un graphique orienté, un cycle e 'une manière d'une plus grande ou égale longueur à cela qu'il commence et il finit sur le même apex. Un graphique il est cyclique défini si dans lui il y a ou plus de cycles, dans le cas contraire, nous dirons que le graphique il est acyclique. Dans le cas orienté du graphique, on indique que le noeud de Vj est à côté du noeud vous si un arc existe de qui le congé et vous atteignent à vous dans Vj, un tel arc vient ledit incident aux noeuds Vi et Vj. Dans le cas dans lequel il est doit que faisant avec un graphique non orienté, il n'a pas le sens de parler au sujet de vous le souci nous adjacents dans combien une telle définition étroitement est attachée à l'orientato de concept d'arc (arc dans que l'ordre important de e 'de son extrémité dirige).

De chaque pu² d'apex au dipartirsi un nombre d'imprecisato de lui les voûtes qui peuvent finir dans une lequel du souci nous du graphique, il peuvent nous produire cela d'un apex deux de dipartano qu'il est arqués que tous les deux dans la même finition d'apex, diverse de celle-là du départ, dans ce cas-ci vous nous concernent du départ et de l'arrivée pour chaque arc elles sont égale, de telles voûtes viennent des parallèles d'énonciations, un graphique qui ne contient pas des parallèles de voûtes est ledit simple.

Pour un apex le degré est défini comme nombre de relati de voûtes vous à lui, plus juste, est parlé au sujet du degré de revenu, afin d'indiquer le nombre de voûtes qu'ils finissent en degré considéré de l'apex e d'évasion afin d'indiquer le nombre de voûtes qui dipartono de l'apex considéré. Un apex qui a un degré nul est ledit isolé et représente un apex de quel dipartono ni l'un ni l'autre elles ne sont les voûtes atteintes. Un graphique il est dit relié s'il y a une distance entre chaque croisillon des noeuds concernant le graphique mêmes, évidemment, un graphique qu'il contient des noeuds que des isolats à vous n'est pas reliés.

Un graphique un indique étroitement relié si pour chaque apex existe une distance directe chaque vers l'autre apex. Les figures qui suivent, illustrent un graphique marqué orienté (du côté gauche) et le graphique correspondant marqué non orienté (vers la droite).

Avoir fourni ensuite une certaine idée générale sur le type de données abstraites GRAFO, nous salut l'heure pour définir de l'heure la représentation.

3) représentation du graphique abstrait de données

Une manière de représenter le graphique abstrait de données est connue avec le nom de la matrice de la contiguîté, dans un tel cas, un graphique est représentée d'une matrice carrée d'ordre de N où N est le nombre de soucis nous concernant le graphique, elles sont dans le biunivoca de correspondance avec les valeurs des index de la ligne et de la colonne de la matrice carrée. Les éléments de la matrice sont de type de booleano et leur valeur vient établi de la règle suivante :

l'élément dans la ligne et la colonne j vaut la peine vrai si dans le graphique un arc de l'apex à l'apex existe j, autrement vaut la peine faux.

Une "boucle" sera représentée du véritable endroit de valeur dans le cas caractérisé de (I , i).

Avantages : Une telle représentation est beaucoup la simple et moins approuve l'accès dirigé l'information relative à l'existence ou qu'un arc qui relie deux vous concernent à nous

Inconvénients : un graphique constitué à partir de N que vous concernez à nous, demandes un matrice NxN, ceci est un problème quand le numero de vous concernent des augmentations de poiché de cresce la mémoire à nous a remarkablly occupées. Un autre inconvénient de cette représentation consiste nel fait que nous ne pouvons pas augmenter le nombre de vous nous concernons que du graphique d'ailleurs ne peut pas être le grafi représenté dans lequel elles apparaissent des parallèles de voûtes.

Selon le type de représentation que un graphique consiste en représentation par une liste de sottoliste, une telle représentation est célèbre avec le nom de la liste de la contiguîté, tous les soucis à nous du graphique est insérés dans une liste et chaque apex a, associé si, une liste ultérieure qui contiendra toutes les voûtes il qu'elles sont provenues d'un tel apex.

Avantages : la condition de mémoire vient pour dépendre seulement du nombre efficace de soucis à nous et les voûtes qu'elles constituent le graphique, d'ailleurs, la représentation est dynamique

Inconvénients : l'accès à un élément du graphique n'est pas dirigé, mais il a besoin du scansion de la liste

Dans notre cas, afin de réaliser le graphique , nous prendrons en compte la représentation au moyen de liste de la contiguîté, du graphique que nous considérerons une représentation limitée de la disponibilité simple de la mémoire du système que les instruments il (forme illimitée), d'ailleurs, la représentation de nous pris en compte contrôleront l'espace mémoire qui est créé pour des annulations certaines.

La complexité de l'algorithme qui met en application le grafi oriente à vous a porté voient qu'encore l'approche au problème en termes de sottoproblemi de la complexité inférieure qui a été optimise à vous singulièrement et plus tard il coordonne à vous. Cette même distance logique sera suivie dans le trattazione qui s'avère donc articulé dans les points suivants :

) endroit de la base d'objets dans laquelle décomposant le problème

b) Description et exécution du polimorfismo

c) Développement d'un applicativo basé sur le GRAPHIQUE de classe

) à l'endroit objecte la base

Un du rappresentazioni possible d'informatique du grafi est celle-là des listes de contiguîté qui, comme précédemment exposé, sont basées sur une liste contenante tout le souci faisant la pièce à nous du graphique à partir de chacun duquel lancez la liste de voûte sortante du même apex.

Dans cet optique il s'avère assez d'intuitivo pour caractériser que l'objet de primitivo qui n'emploie pas d'autres objets l'ARC_NODE, caractérise plus tard l'objet ARC_LIST qui est la liste qui réunit tout l'ARC_NODE, continuant dans le développement logique que le dipana VERTEX_NODE dont l'ARC_LIST est eu et finalement on a le VERTEX_LIST qui donne un point de vue logique coïncide avec l'objet GRAFO.

Nous passons l'heure à l'analyse des objets simples dans l'ordre surexposé :

ARC_NODE

//Arc_Node.h : interface pour la classe d'Arc_Node.

# if!defined(AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Element.h"

classe Arc_Node

{

classe Arc_List d'ami ;

protégé :

Gen_Data_Ptr Arc_Destination ;

Gen_Data_Ptr Arc_Attribute ;

Arc_Node * Next_Arc ;

public :

Display_An_Arc() vide ;

Arc_Node(Gen_Data_Ptr The_Attribute, Gen_Data_Ptr The_Destination) ;

~Arc_Node() virtuel ;

} ;

# endif / /!defined(AFX_ARC_NODE_H__4D70C386_7844_11D1_BECF_444553540000__INCLUDED _)

Car l'Arc_List est regardé est l'ami avoué qui donc pourra approcher les données décrites dans la partie privée qui est 2 gunlayers du type de Gen_Data_Ptr qui dans l'ÉLÉMENT de classe vient défini comme un gunlayer à un objet de type ÉLÉMENT. Ces 2 gunlayers concourent donc pour ne pas lier le type ni l'un ni l'autre de l'attribut de l'arc de de l'attribut de l'apex de destination. Un gunlayer au noeud successif dans la liste est eu alors des voûtes inhérentes un apex de données.

Les opérations définies sur chaque objet du type ARC_NODE sont sa création et initialisation contemporaine, la destruction et la déclaration suivante de visualisation deuxièmes :

//Arc_Node.cpp : exécution de la classe d'Arc_Node.

# elle inclut "Arc_Node.h"

# elle inclut < iostream.h >

//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()

{

}

//affichage

vide Arc_Node::Display_An_Arc()

{

Arc_Attribute->Display() ;

cout < < "-->" ;

Arc_Destination->Display() ;

cout < < "\t" ;

}

Le Display_An_Arc ne fait pas autre que pour appliquer la méthode d'affichage a défini pour l'ÉLÉMENT de classe et ses classes dérivées à Arc_Attribute et à Arc_Destination qui sont des gunlayers à cette classe, obtenant donc la visualisation de l'attribut de l'arc et de l'apex de destination.

ARC_LIST

//Arc_List.h : interface pour la classe d'Arc_List.

# if!defined(AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Arc_Node.h"

classe Arc_List

{

protégé :

Arc_Node * Arc_List_Head ;

public :

Arc_Node * Is_Member_Of(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Destination) ;

Clear() vide ;

Number_Of_Arcs_In() interne ;

bool Remove(Gen_Data_Ptr The_Arc, Gen_Data_Ptr The_Destination) ;

Display_Arcs() vide ;

Insert(Gen_Data_Ptr vide The_Attribute, Gen_Data_Ptr The_Destination) ;

Arc_List() ;

~Arc_List() virtuel ;

} ;

# endif / /!defined(AFX_ARC_LIST_H__4D70C384_7844_11D1_BECF_444553540000__INCLUDED _)

Les seules données protégées de cette classe sont un gunlayer à un ARC_NODE qu'il sera le premier de la liste de voûtes sortantes de l'apex de données pour lequel la classe il vient istanziata. Dans la partie publique il y a la définition des normes d'eseguibili d'opérations sur une liste, leur déclaration est suivant :

//Arc_List.cpp : exécution de la classe d'Arc_List.

# elle inclut < iostream.h >

# elle inclut "Arc_List.h"

//Construction/Destruction

Arc_List::Arc_List()

{

Arc_List_Head = 0 ;

}

Arc_List::~Arc_List()

{

}

//Inserzione d'un élément dans la tête à la liste de voûtes, les mémoires qui dans la représentation de nous l'ont présentée n'a pas

le sens de //alcun de visionner une insertion rangée des voûtes exactement pour la nature hétérogène des données s'occupe à vous.

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

{

Arc_Node * Arc_Node_Ptr ;

bout de //Vertex_Node_Ptr à un nouveau Vertex_Node

Arc_Node_Ptr = nouveaux Arc_Node(The_Attribute, The_Destination) ;

//places dans la tête à la liste le nouvel apex

== d'if(Arc_List_Head 0)

{ LISTE de //EMPTY

Arc_List_Head = Arc_Node_Ptr ;

Arc_Node_Ptr->Next_Arc = 0 ;

}

autrement

{ //NOT VIDENT LA LISTE

Arc_Node_Ptr->Next_Arc = Arc_List_Head ;

Arc_List_Head = Arc_Node_Ptr ;

}

//visualization de toutes les voûtes il concernant la liste

vide Arc_List::Display_Arcs()

{

== d'if(Arc_List_Head 0)

{

le cout < < des "arcs de \tNo partent de ce sommet" < < endl ;

}

autrement

{

Arc_Node * Arc_Node_Ptr ;

Arc_Node_Ptr = Arc_List_Head ;

while(Arc_Node_Ptr ! = 0)

{// cycle est péché répété quand il n'est pas NUL

Arc_Node_Ptr->Display_An_Arc() ;

Arc_Node_Ptr = Arc_Node_Ptr->Next_Arc ;

}

//Elimination d'un arc de la liste

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

{

//point un gunlayer à la tête de la 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 du noeud à enlever

while((Arc_Node_Ptr_1 ! = 0) &&

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

())))) de !(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)

{// j'AI TROUVÉ l'ÉLÉMENT POUR ENLEVER

if(Arc_Node_Ptr_1 ! = Arc_List_Head)

Arc_Node_Ptr_2->Next_Arc = Arc_Node_Ptr_1->Next_Arc ;

autrement l'ARC À ENLEVER est le premier de la LISTE

Arc_List_Head = Arc_List_Head->Next_Arc ;

//elimination de l'arc

effacement Arc_Node_Ptr_1 ;

de retour rectifiez ;

}

autrement

{// ÉLÉMENT NON TROUVÉ

faux de retour ;

}

//it donne en arrière le nombre de voûtes sortantes d'un apex

Arc_List::Number_Of_Arcs_In() interne

{

N_Arcs interne = 0 ;

Arc_Node * Arc_Node_Ptr ;

Arc_Node_Ptr = Arc_List_Head ;

while(Arc_Node_Ptr ! = 0)

{// cycle est péché répété quand il n'est pas NUL

N_Arcs ;

Arc_Node_Ptr = Arc_Node_Ptr->Next_Arc ;

}

N_Arcs de retour ;

}

la fonction de membre de //This est faite attention pour décommander toutes les voûtes à elle présent dans la liste

vide Arc_List::Clear()

{

Arc_Node * Arc_Node_Ptr ;

Arc_Node_Ptr = Arc_List_Head ;

while(Arc_Node_Ptr ! = 0)

{// cycle est péché répété quand il n'est pas NUL

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

Arc_Node_Ptr = Arc_List_Head ;

}

la fonction de //Questa est faite attention pour établir si les marques d'un arc de données partie déjà de la liste les met en oeuvre et dans le cas l'arc vient

//individuato certains qu'il lui donne en arrière un gunlayer vient autrement donné en arrière le gunlayer de la liste fine qui est 0

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 ;

}

Arc_Node_Ptr de retour ;

}

Vous vous notez que dans l'ENLÈVEMENT et dans l'IS_MEMBER_OF je l'emploie de la méthode IS_EQUAL définie sur le type ÉLÉMENT et dérive à vous, qu'il concourt pour établir l'égalité des objectifs de données de la conversion de previa de 2 gunlayers en vous au moyen de Type_Casting de gunlayer à un ÉLÉMENT d'objet au gunlayer à FLOAT_OBJ ou CHAR_OBJ ou INT_OBJ.

VERTEX_NODE

//Vertex_Node.h : interface pour la classe de Vertex_Node.

# if!defined(AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Graph.h"

# il inclut "Arc_List.h"

classe Vertex_Node

{

graphique de classe d'ami ;

protégé :

Gen_Data_Ptr Vertex_Attribute ;

Reference_Count interne non signé ;

Arc_List * Arc_List_Ptr ;

Vertex_Node * Next_Vertex ;

public :

Display_Vertex_And_Arcs() vide ;

Display_Vertex() vide ;

Vertex_Node(Gen_Data_Ptr The_Attribute) ;

~Vertex_Node() virtuel ;

} ;

# endif / /!defined(AFX_VERTEX_NODE_H__4D70C387_7844_11D1_BECF_444553540000__INCLUDED _)

En outre dans ce cas-ci il vient défini comme le GRAPHIQUE de classe d'ami (ce nous nous rappelons l'équivalent au VERTEX_LIST) dans combien doit avoir le libre accès aux champs du Vertex_Node simple duquel se compose. Dans le segment protégé l'information apparaissez de ce que chaque Vertex_Node se compose qui est un attribut dont le type a priori ne vient pas limite en second lieu combien déjà décrit pour le Vertex_Node, positif entier le témoin d'un certain nombre de voûtes entrant dans l'apex, l'information de l'allorchè primaire d'importance devra être décidé si l'apex est dismissable ou moins, est alors un gunlayer à un type chaque apex d'ARC_LIST donc sait où il commence la liste de ses voûtes sortantes. Enfin il y a un gunlayer au prochain VERTEX_NODE dans le VERTEX_LIST.

Nous passons l'heure à la déclaration de la fonction de membre :

//Vertex_Node.cpp : exécution de la classe de Vertex_Node.

# elle inclut < iostream.h >

# elle inclut "Vertex_Node.h"

//Construction/Destruction

Vertex_Node::Vertex_Node(Gen_Data_Ptr The_Attribute)

{

Arc_List_Ptr = nouvel Arc_List ;

Next_Vertex = 0 ;

Reference_Count = 0 ;

Vertex_Attribute = The_Attribute ;

}

Vertex_Node::~Vertex_Node()

{

}

//visualisation du nom simple de l'apex

vide Vertex_Node::Display_Vertex()

{

Vertex_Attribute->Display() ;

if(Next_Vertex ! = 0)

cout < < "," ;

autrement

cout < < endl ;

}

//Visualizzazione du nom de l'apex des voûtes d'eux sortants et à eux vous nous concernent de destination

vide Vertex_Node::Display_Vertex_And_Arcs()

{

cout de "\nVertice" < < ;

Vertex_Attribute->Display() ;

cout < < "entrer de \n\tArchi : "< < Reference_Count ;

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

Arc_List_Ptr->Display_Arcs() ;

}

Jusque le constructeur vous vous notez qu'en second lieu combien exigé du C VISUEL les 5.0 gunlayers vient directement inizializzati à 0 et pas à la NULLE comme se produit dans d'autres langues ou versions précédentes. D'ailleurs l'initialisation du champ ARC_LIST_PTR arrive directement exigeant à la mémoire de logiciel d'exploitation pour un objet du type ARC_LIST qui exactement sera visé d'ARC_LIST_PTR.

Il y a deux diverses fonctions de la visualisation définies sur un VERTEX_NODE, avant que la méthode d'affichage d'ÉLÉMENT de classe seul visualise le rappel de l'apex et ses dérivés tandis que le second visualise également la voûte il sortant en utilisant la méthode de Display_Arcs définie sur le type ARC_LIST.

GRAPHIQUE (Vertex_List)

//Graph.h : interface pour la classe de graphique.

# if!defined(AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Arc_List.h"

# il inclut "Arc_Node.h"

classez le graphique //class qui met en application la liste de vous souci à nous

{

classe Vertex_Node d'ami ;

protégé :

Vertex_Node * Tête ; //tip toujours à la tête de la liste

public :

Number_Of_Arcs_In() interne ;

Clear() vide ;

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

Display_Graph() vide ;

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) ;

Number_Of_Vertices_In() interne ;

bool Remove_Vertex(Gen_Data_Ptr The_Source) ;

Display_Only_Vertex() vide ;

Insert(Gen_Data_Ptr vide The_Attribute) ;

Graph() ;

~Graph() virtuel ;

} ;

# endif / /!defined(AFX_Graph_H__4D70C385_7844_11D1_BECF_444553540000__INCLUDED _)

En outre dans ce cas-ci donc car elle s'était produite pour l'ARC_LIST la seule information confidentielle est le gunlayer au premier VERTEX_NODE concernant la liste et dans la partie publique les opérations apparaissent des normes d'eseguibili sur une liste.

//Graph.cpp : exécution de la classe de graphique.

# elle inclut < iostream.h >

# elle inclut "Graph.h"

# elle inclut "Vertex_Node.h"

//Construction/Destruction

Graph::Graph()

{

Tête = 0 ;

}

Graph::~Graph()

{

}

//Inserisce que un apex dans la tête à la liste de vous concernent à nous commandant qu'il n'est pas déjà présent dans quel cas ne se produit pas duplication.

Graph::Insert(Gen_Data_Ptr vide The_Attribute)

{

if(Is_Member_Of(The_Attribute))

{

le cerr < < "l'apex est déjà présent dans le graphique." < < endl ;

retour ;

}

Vertex_Node * Vertex_Node_Ptr ;

bout de //Vertex_Node_Ptr à un nouveau Vertex_Node

Vertex_Node_Ptr = nouveau Vertex_Node(The_Attribute) ;

//places dans la tête à la liste le nouvel apex

if(!Head)

{// LISTE VIDE

Tête = Vertex_Node_Ptr ;

Vertex_Node_Ptr->Next_Vertex = 0 ;

}

autrement

{// LISTE NON VIDE

Vertex_Node_Ptr->Next_Vertex = Tête ;

Tête = Vertex_Node_Ptr ;

}

//Visualizza que les attributs simples de vous concernent à nous.

vide Graph::Display_Only_Vertex()

{

== d'if(Head 0)

{

cout < < "pas sommet dans ce graphique" < < endl ;

}

autrement

{

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

while(Vertex_Node_Ptr ! = 0)

{

//cycle est le péché répété quand il n'est pas NUL

Vertex_Node_Ptr->Display_Vertex() ;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

//Rimozione d'un apex simple et de ses voûtes de previo de graphique une commande que l'apex n'est pas destination d'un certain arc.

bool Graph::Remove_Vertex(Gen_Data_Ptr Vertex_To_Remove)

{// point un gunlayer à la tête de la liste

Vertex_Node * Vertex_Node_Ptr_1 ;

Vertex_Node * Vertex_Node_Ptr_2 ;

Vertex_Node_Ptr_1 = tête ;

Vertex_Node_Ptr_2 = tête ;

//search du noeud à enlever

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 ;

}

//commande que l'apex existe et qu'il n'est pas dirigé d'un certain arc

if((Vertex_Node_Ptr_1 ! = 0)&&

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

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

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

{

//porte toutes les voûtes à lui sortant de l'apex

Arc_Node * Arc_Node_Ptr ;

Arc_Node_Ptr = Vertex_Node_Ptr_1->Arc_List_Ptr->Arc_List_Head ;

while(Arc_Node_Ptr ! = 0)

{// cycle est péché répété quand il n'est pas NUL

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 ONT TROUVÉ l'ÉLÉMENT POUR ENLEVER

if(Vertex_Node_Ptr_1 ! = tête)

Vertex_Node_Ptr_2->Next_Vertex = Vertex_Node_Ptr_1->Next_Vertex ;

l'ARC d'autre de //the À ENLEVER est le premier de la LISTE

Chef = Chef->Next_Vertex ;

//I éliminent le vertice

effacement Vertex_Node_Ptr_1 ;

de retour rectifiez ;

} ;

if(Vertex_Node_Ptr_1 == 0)

{

le cerr < < "l'apex à éliminer n'a pas été trouvé" < < endl ;

}

autrement

{

le cerr < < "l'apex n'est pas dismissable dans de combien de destination" ;

cerr < < Vertex_Node_Ptr_1->Reference_Count < < "voûtes." < < endl ;

}

faux de retour ;

}

//determination du nombre de vous nous concernent de ce que le graphique se compose.

Graph::Number_Of_Vertices_In() interne

{

N_Vertex interne = 0 ;

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

while(Vertex_Node_Ptr ! = 0)

{ le cycle de //the est péché répété quand il n'est pas NUL

N_Vertex ;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

N_Vertex de retour ;

}

//Determination si l'apex appartient ou moins au graphique avec la restitution du gunlayer au même apex dans le cas

//it vient caractérisé, autrement il vient donné en arrière le gunlayer qui ferme la liste 0 qui est et donc la fonction donne en arrière

//FALSE si l'apex ne vient pas caractérisé.

Vertex_Node * Graph::Is_Member_Of(Gen_Data_Ptr The_Attribute)

{

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

while((Vertex_Node_Ptr ! = 0) &&

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

{

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

Vertex_Node_Ptr de retour ;

}

la fonction de membre de //Questa exécute la création d'une commande de previo d'arc de l'existence de la source et de la destination d'apex

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) ;

== d'if(Source_Vertex_Ptr 0)

{

le cerr < < "la source d'apex est inesistente\n" ;

faux de retour ;

}

Vertex_Node * Dest_Vertex_Ptr ;

Dest_Vertex_Ptr = Is_Member_Of(Dest_Vertex) ;

== d'if(Dest_Vertex_Ptr 0)

{

le cerr < < "l'apex de destination est inesistente\n" ;

faux de retour ;

}

//Increment le compte de référence de l'arc de destination

Dest_Vertex_Ptr->Reference_Count ;

//Creation de l'arc

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

de retour rectifiez ;

}

//Visualizzazione de tous les noeuds et de toutes les voûtes il concernant le graphique.

vide Graph::Display_Graph()

{

== d'if(Head 0)

{

cout < < "pas sommet dans ce graphique" < < endl < < endl ;

}

autrement

{

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

while(Vertex_Node_Ptr ! = 0)

{ le cycle de //the est péché répété quand il n'est pas NUL

Vertex_Node_Ptr->Display_Vertex_And_Arcs() ;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

//Rimozione d'une commande de previo d'arc de données de l'existence de la même. La fonction s'exécute également

décroissance de //the du REFERENCE_COUNT de l'apex de destination de l'arc.

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

{

//control que la source d'apex existe

Vertex_Node * Source_Vertex_Ptr ;

Source_Vertex_Ptr = Is_Member_Of(Source_Vertex) ;

== d'if(Source_Vertex_Ptr 0)

{

le cerr < < "source d'apex de \nIl est inexistant" ;

//monster que la liste de vous concernent à nous

Display_Only_Vertex() ;

faux de retour ;

}

Vertex_Node * Dest_Vertex_Ptr ;

Dest_Vertex_Ptr = Is_Member_Of(Dest_Vertex) ;

== d'if(Dest_Vertex_Ptr 0)

{

le cerr < < "apex de destination de \nIl est inexistant" ;

Source_Vertex_Ptr->Display_Vertex_And_Arcs() ;

faux de retour ;

}

Arc_Node * Arc_Node_Ptr ;

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

== d'if(Arc_Node_Ptr 0)

{

le cerr < < "\nL 'arc à éliminer est inexistant" ;

Source_Vertex_Ptr->Display_Vertex_And_Arcs() ;

faux de retour ;

}

autrement

{

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

--; de Dest_Vertex_Ptr->Reference_Count

de retour rectifiez ;

}

//Eliminazione de toutes les voûtes à eux et de tous vous nous concernent concernant le graphique, ceci pour la compatibilité avec la commande de

//Reference_Count elle se produit qu'éliminant avant des voûtes de chaque apex à elle sortante et alors éliminant tous vous concernez à nous.

vide Graph::Clear()

{

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

//Removal des voûtes de tous les soucis à nous

while(Vertex_Node_Ptr ! = 0)

{ le cycle de //the est péché répété quand il n'est pas NUL

Vertex_Node_Ptr->Arc_List_Ptr->Clear() ;

Vertex_Node_Ptr->Reference_Count = 0 ;

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

//Removal de vous souci à nous

Vertex_Node_Ptr = Tête ;

while(Vertex_Node_Ptr ! = 0)

{ le cycle de //the est péché répété quand il n'est pas NUL

Remove_Vertex(Vertex_Node_Ptr->Vertex_Attribute) ;

Vertex_Node_Ptr = Tête ;

}

//Calculation du nombre de voûtes actuelles dans le graphique a obtenu s'appliquer à chaque apex l'omonima

//function défini pour l'ARC_LIST.

Graph::Number_Of_Arcs_In() interne

{

N_Arcs interne = 0 ;

Vertex_Node * Vertex_Node_Ptr ;

Vertex_Node_Ptr = Tête ;

while(Vertex_Node_Ptr ! = 0)

{ le cycle de //the est péché répété quand il n'est pas NUL

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

Vertex_Node_Ptr = Vertex_Node_Ptr->Next_Vertex ;

}

N_Arcs de retour ;

}

b) Description et exécution du polimorfismo

Avec le polimorfismo de limite nous voulons dire la capacité à une base de classe de définir des fonctions qui viennent redéfini des classes dérivées, et de la possibilité du compilateur pour exécuter l'attache en retard que vous rappelez la méthode pour la classe juste dérivée au moyen d'une commande sur l'objet de rappel la fonction. Peut-être dans un tel contexte que l'application plus signicative est juste ceci de nous a mis en application qui est la possibilité à éviter d'écrire pour chaque fonction d'autres n fonctionne afin de mettre en application les types possibles de n de données.

La solution consiste en installant une classe abstraite que l'ÉLÉMENT dont les vraies classes à de divers types de n de données dérivent le parent de n, dans notre cas ont étée FLOAT_OBJ mis en application, INT_OBJ et CHAR_OBJ, l'ognuna di.le qui redéfinissent le constructeur, la fonction et la fonction IS_EQUAL d'affichage plus tard décrits.

ÉLÉMENT

//Element.h : interface pour la classe d'élément.

# if!defined(AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

char Class_Name[20 de typedef ] ;

# il inclut < string.h >

élément de classe

{

public :

bool virtuel Is_Equal(Element * Element_Ptr) ;

Display() vide virtuel ;

char * Get_Class() ;

Element() ;

~Element() virtuel ;

protégé :

Class_Name My_Class ;

} ;

élément de typedef * Gen_Data_Ptr ; //defines un gunlayer à la classe d'élément

# endif / /!defined(AFX_ELEMENT_H__25FF6141_7852_11D1_BECF_444553540000__INCLUDED _)

Cette classe a comme seulement des données protégées et donc ereditabile contre les classes dérivées le nom de la classe, l'information qui sera laddove utile d'un objet de données devra déterminer ce qui a dérivé la classe appartient et s'il est visé d'un gunlayer à l'ÉLÉMENT de mère de classe.

Elle vient a d'ailleurs défini un gunlayer à cette classe qui alors sera employée dans toutes les fonctions qui importeront ELEMENT.H afin de caractériser un gunlayer à un type de données génériques.

La déclaration du public de fonctions est suivante :

//Element.cpp : exécution de la classe d'élément.

# elle inclut "Element.h"

//Construction/Destruction

Element::Element()

{

strcpy(My_Class, "élément") ;

}

Element::~Element()

{

}

//Returns le nom de la classe

char * Element::Get_Class()

{

My_Class de retour ;

}

la fonction de //Questa est redéfinie des classes dérivées.

vide Element::Display()

{

}

la fonction de //Questa est virtuelle et donc redéfini des classes dérivées, elle fait attention elle-même pour établir l'égalité des données

la classe de //della qu'elle vient a appliqué la méthode avec la classe visée à partir du gunlayer qui est reçu dans le revenu.

bool Element::Is_Equal(Element * Element_Ptr)

{

faux de retour ;

}

Nous voyons l'heure pendant que les classes dérivées redéfinissent les fonctions virtuelles de l'ÉLÉMENT de classe :

INT_OBJ

//Int_Obj.h : interface pour la classe d'Int_Obj.

# if!defined(AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Element.h"

classe Int_Obj : élément public

{

public :

Display() vide ;

bool Is_Equal(Element * Element_Ptr) ;

Get_Val() interne ;

Int_Obj() ;

Int_Obj(int Int_Data) ;

~Int_Obj() virtuel ;

protégé :

valeur interne ;

} ;

# endif / /!defined(AFX_INT_OBJ_H__25FF6142_7852_11D1_BECF_444553540000__INCLUDED _)

Dans ce cas-ci les seules données protégées sont une valeur que c'est solo accessible de la classe d'Int_Obj et elles ne donnent pas à la mère de classe qu'elles imposent qui même si le code de l'affichage est égal pour tous et les 3 classes dérivées, un tel code ne sont pas implementabile dans la base de classe.

La déclaration correspondante est suivante :

//Int_Obj.cpp : exécution de la classe d'Int_Obj.

# elle inclut < iostream.h >

# elle inclut "Int_Obj.h"

//Construction/Destruction

Int_Obj::Int_Obj()

{

strcpy(My_Class, "Int_Obj") ;

}

Int_Obj::~Int_Obj()

{

}

//constructeur d'inizializzatore

Int_Obj::Int_Obj(int Int_Data)

{

strcpy(My_Class, "Int_Obj") ;

Valeur = Int_Data ;

}

//Get_Val

Int_Obj::Get_Val()

{

valeur de retour ;

}

//affichage

vide Int_Obj::Display()

{

cout < < valeur ;

}

//IS_EQUAL

la fonction de //Questa concourt pour vérifier si la valeur de l'objet pour lequel on le rappelle est égale à la valeur

objet de //della de type ÉLÉMENT qu'elle reçoit dans le revenu. Ci² se produit conversion de previa du gunlayer à

//ELEMENT dans un gunlayer à INT_OBJ.

bool Int_Obj::Is_Equal(Element * Element_Ptr)

{

le strcmp de //the donne en arrière 0 si le stringhe 2 ils sont égal

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

faux de retour ;

autrement

{

//je convertis le gunlayer générique dans un gunlayer en entier

Int_Obj * Int_Obj_Ptr = (Int_Obj *)Element_Ptr ;

//comparison que les données se dirigent à vous des 2 gunlayers

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

}

CHAR_OBJ

//Char_Obj.h : interface pour la classe de Char_Obj.

# if!defined(AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Element.h"

classe Char_Obj : élément public

{

protégé :

valeur de char ;

public :

Char_Obj() ;

Char_Obj(char Char_Data) ;

~Char_Obj() virtuel ;

Display() vide ;

bool Is_Equal(Element * Element_Ptr) ;

char Get_Val() ;

} ;

# endif / /!defined(AFX_HAR_OBJ_H__882EFA81_7A44_11D1_BECF_444553540000__INCLUDED _)

La déclaration correspondante est suivante :

//Char_Obj.cpp : exécution de la classe de Char_Obj.

# elle inclut "har_Obj.h"

# elle inclut < iostream.h >

//Construction/Destruction

Char_Obj::Char_Obj()

{

strcpy(My_Class, "Char_Obj") ;

}

//constructeur d'inizializzatore

Char_Obj::Char_Obj(char Char_Data)

{

strcpy(My_Class, "Char_Obj") ;

Valeur = Char_Data ;

}

Char_Obj::~Char_Obj()

{

}

//GET_VAL

char Char_Obj::Get_Val()

{

valeur de retour ;

}

bool Char_Obj::Is_Equal(Element * Element_Ptr)

{

le strcmp de //the donne en arrière 0 si le stringhe 2 ils sont égal

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

faux de retour ;

autrement

{

//je convertis le gunlayer générique dans un gunlayer

//to entier

Char_Obj * Char_Obj_Ptr = (Char_Obj *)Element_Ptr ;

//comparison que les données se dirigent à vous des 2 gunlayers

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

}

//affichage

vide Char_Obj::Display()

{

cout < < valeur ;

}

FLOAT_OBJ

//Float_Obj.h : interface pour la classe de Float_Obj.

# if!defined(AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _)

# définissez AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _

# si _ MSC_VER > = 1000

# onces de pragma

# / d'endif / _ MSC_VER > = 1000

# il inclut "Element.h"

classe Float_Obj : élément public

{

public :

Float_Obj() ;

Float_Obj(float Float_Data) ;

~Float_Obj() virtuel ;

Display() vide ;

bool Is_Equal(Element * Element_Ptr) ;

flotteur Get_Val() ;

protégé :

valeur de flotteur ;

} ;

# endif / /!defined(AFX_FLOAT_OBJ_H__882EFA82_7A44_11D1_BECF_444553540000__INCLUDED _)

La déclaration de la classe FLOAT_OBJ est suivante :

//Float_Obj.cpp : exécution de la classe de Float_Obj.

# elle inclut < iostream.h >

# elle inclut "Float_Obj.h"

//Construction/Destruction

Float_Obj::Float_Obj()

{

strcpy(My_Class, "Float_Obj") ;

}

Float_Obj::~Float_Obj()

{

}

//constructeur d'inizializzatore

Float_Obj::Float_Obj(float Float_Data)

{

strcpy(My_Class, "Float_Obj") ;

Valeur = Float_Data ;

}

//GET_VAL

flotteur Float_Obj::Get_Val()

{

valeur de retour ;

}

//IS_EQUAL

bool Float_Obj::Is_Equal(Element * Element_Ptr)

{

le strcmp de //the donne en arrière 0 si le stringhe 2 ils sont égal

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

faux de retour ;

autrement

{

converti de //I le gunlayer générique dans un gunlayer à Float_Obj

Float_Obj * Float_Obj_Ptr = (Float_Obj *)Element_Ptr ;

//comparison que les données se dirigent à vous des 2 gunlayers

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

}

//AFFICHAGE

vide Float_Obj::Display()

{

cout < < valeur ;

}

Pendant que ces classes peuvent être employées afin de mettre en application un graphique avec la voûte et concerner avoir les attributs à nous de n'importe quelle sorte entre cette heure définie sont illustré dans le suivant divisent en paragraphes.

c) développement d'applicativo basé sur le GRAPHIQUE de classe

Suivre d'Applicativo est soutenu de la condition de voir pour travailler le membre que la fonction définie pour la classe de graphique est donc limitée pour installer un menu des opérations d'eseguibili sur les mêmes, à l'ognuna di.le qu'une fonction est associée que, laddove nécessaire, approvisionnements pour exiger au client des données de revenu qui à l'eempio les attributs pour l'arc ou à l'apex de destination ou de source d'apex. La fonction de Type_Selection est d'ailleurs le présent dont pour chacun de l'excédent de caisses précise à vous approuve le client pour insérer le tipologia puisqu'il est d'accord sur l'insertion, une telle fonction ne fera pas autre qui pour aller à l'istanziare l'objet juste entre FLOAT_OBJ, CHAR_OBJ et INT_OBJ et la fabrication pour le viser d'un des gunlayers à avoir l'ossia général Source_Name_Ptr de visibilité d'ÉLÉMENT de classe, Dest_Name_Ptr ED Arc_Name_Ptr.

# elle inclut "Graph.h"

# elle inclut "Arc_List.h"

# elle inclut "Element.h"

# elle inclut "Int_Obj.h"

# elle inclut "har_Obj.h"

# elle inclut "Float_Obj.h"

# elle inclut < ctype.h >

# elle inclut < string.h >

# elle inclut < iostream.h >

# elle inclut < conio.h >

//MANIPULATING DU GRAFO

Insert() vide ;

Create() vide ;

Display() vide ;

Number_Of_Vertices_In() vide ;

Number_Of_Arcs_In() vide ;

bon y_Arc() vide ;

bon y_Vertex() vide ;

bon y_Graph() vide ;

//PER LE POLIMORFISMO

char Type_Selection() ;

Set_Arc_Name() vide ;

Set_Source_Vertex_Name() vide ;

Set_Dest_Vertex_Name() vide ;

Élément * Source_Name_Ptr, * Dest_Name_Ptr, * Arc_Name_Ptr ;

Graphique * My_Graph ;

main() vide

{

cout<<"\n\n" ;

cout<< "\n de ____________________________________________________________" ;

cout<< " | |\n ";

cout<< " | - PROGRAMME De GESTION D'un GRAFO ORIENTÉ - |\n ";

cout<< " |____________________________________________________________ |\n ";

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

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

cout<< " | |\n ";

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

cout<< " | |\n ";

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

cout<< " | |\n ";

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

réponse de char ;

cin > > réponse ;

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

bool encore ;

My_Graph = nouveau graphique ;

Je donne

{

cout<<"\n" ;

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

cout < < "* Prego pour choisir une des options suivantes : * \n ";

cout < < "* 1) insertion du vertice a * \n" ;

cout < < "* 2) insertion de l'arco a * \n" ;

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

cout < < "* 4) détermination du nombre de vertici * \n" ;

cout < < "* 5) détermination du nombre d'archi * \n" ;

cout < < "* 6) élimination de l'arco a * \n" ;

cout < < "* 7) élimination du vertice a * \n" ;

cout < < "* 8) élimination du graphique a * \n" ;

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

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

cin > > réponse ;

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)

{

maisons '1 ':

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

cout < < "\t\t\t * insertion du vertice a * \n" ;

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

Insert() ;

encore = rectifiez ;

continuez ;

maisons '2 ':

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

cout < < "\t\t\t * insertion de l'arco a * \n" ;

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

Create() ;

encore = rectifiez ;

continuez ;

maisons '3 ':

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

cout < < "\t\t\t * visualisation du graphique * \n" ;

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

Display() ;

encore = rectifiez ;

continuez ;

maisons '4 ':

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

cout < < "\t\t\t * détermination du n du vertici * \n" ;

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

Number_Of_Vertices_In() ;

encore = rectifiez ;

continuez ;

maisons '5 ':

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

cout < < "\t\t\t * détermination du n des voûtes * \n" ;

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

Number_Of_Arcs_In() ;

encore = rectifiez ;

continuez ;

maisons '6 ':

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

cout < < "\t\t\t * élimination de l'arco a * \n" ;

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

Bon y_Arc() ;

encore = rectifiez ;

continuez ;

maisons '7 ':

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

cout < < "\t\t\t * élimination du vertice a * \n" ;

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

Bon y_Vertex() ;

encore = rectifiez ;

continu ;

maisons '8 ':

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

cout < < "\t\t\t * élimination de graphique * \n" ;

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

Bon y_Graph() ;

encore = rectifiez ;

continu ;

maisons '0 ':

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

cout < < "\t\t\t * voyez-vous...... * \n" ;

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

encore = faux ;

continu ;

défaut :

encore = rectifiez ;

continu ;

/ d'amende}/du commutateur

Amende } //of que je donne

while(again) ;

}

//Inserzione d'un apex dans le graphique

Insert() vide

{

Set_Source_Vertex_Name() ;

My_Graph->Insert(Source_Name_Ptr) ;

}

//Creazione d'un arc

Create() vide

{

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 du graphique

Display() vide

{

My_Graph->Display_Graph() ;

}

//Visualizzazione du nombre de vous concernent à nous présents dans le graphique

Number_Of_Vertices_In() vide

{

le cout < < "dans le graphique est présent" ;

cout < < My_Graph->Number_Of_Vertices_In() ;

cout < < "vous concernez à nous." < < endl ;

}

//Visualizzazione du nombre de voûtes présentent dans le graphique

Number_Of_Arcs_In() vide

{

le cout < < "dans le graphique est présent" ;

cout < < My_Graph->Number_Of_Arcs_In() ;

cout < < "voûtes." < < endl ;

}

//Eliminazione d'un arc du graphique

bon y_Arc() vide

{

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 d'un apex du graphique

bon y_Vertex() vide

{

Set_Source_Vertex_Name() ;

My_Graph->Remove_Vertex(Source_Name_Ptr) ;

}

//Eliminazione du graphique

bon y_Graph() vide

{

My_Graph->Clear() ;

}

//Visualizzazione de protégé du choix du type de données

char Type_Selection()

{

char Data_Type ;

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

cout < < char "de *c de \t) -128 à 127 * \n" ;

cout < < "\t * F) flotteur 3.4*(10**-38) 3.4*(10 à ** 38) * \n" ;

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

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

cin > > Data_Type ;

retour (toupper(Data_Type)) ;

}

le procédé de //Questa vise Source_Name_Ptr à l'adresse de l'objet cet employé d'istanzia lui-même

//this durent un du type de données choisies

Set_Source_Vertex_Name() vide

{

bool encore ;

cout < < "pour choisir le type de données pour l'apex sorgente:\n\n" ;

Je donne

{

switch(Type_Selection())

{

maisons 'là :

char Char_Data ;

cout < < "Immettere l'attribut (char) : ";

cin > > Char_Data ;

Source_Name_Ptr = nouveau Char_Obj(Char_Data) ;

encore = faux ;

continu ;

maisons 'I':

Int_Data interne ;

cout < < "Immettere l'attribut (long interne) : ";

cin > > Int_Data ;

Source_Name_Ptr = nouvel Int_Obj(Int_Data) ;

encore = faux ;

continu ;

maisons 'F ':

flotteur Float_Data ;

cout < < "Immettere l'attribut (flotteur) : ";

cin > > Float_Data ;

Source_Name_Ptr = nouveau Float_Obj(Float_Data) ;

encore = faux ;

continu ;

défaut :

encore = rectifiez ;

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

continu ;

}

== de}while(again vrai) ;

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

}

le procédé de //Questa vise Dest_Name_Ptr à l'adresse de l'objet cet employé d'istanzia lui-même

//this durent un du type de données choisies

Set_Dest_Vertex_Name() vide

{

bool encore ;

cout < < "pour choisir le type de données pour l'apex de destinazione:\n\n" ;

Je donne

{

switch(Type_Selection())

{

maisons 'là :

char Char_Data ;

cout < < "Immettere l'attribut (char) : ";

cin > > Char_Data ;

Dest_Name_Ptr = nouveau Char_Obj(Char_Data) ;

encore = faux ;

continu ;

maisons 'I':

Int_Data interne ;

cout < < "Immettere l'attribut (long interne) : ";

cin > > Int_Data ;

Dest_Name_Ptr = nouvel Int_Obj(Int_Data) ;

encore = faux ;

continu ;

maisons 'F ':

flotteur Float_Data ;

cout < < "Immettere l'attribut (flotteur) : ";

cin > > Float_Data ;

Dest_Name_Ptr = nouveau Float_Obj(Float_Data) ;

encore = faux ;

continu ;

défaut :

encore = rectifiez ;

continu ;

}

== de}while(again vrai) ;

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

}

le procédé de //Questa vise Arc_Name_Ptr à l'adresse de l'objet cet employé d'istanzia lui-même

//this durent un du type de données choisies

Set_Arc_Name() vide

{

bool encore ;

cout < < "pour choisir le type de données pour l'arc:\n\n" ;

Je donne

{

switch(Type_Selection())

{

maisons 'là :

char Char_Data ;

cout < < "Immettere l'attribut (char) : ";

cin > > Char_Data ;

Arc_Name_Ptr = nouveau Char_Obj(Char_Data) ;

encore = faux ;

continu ;

maisons 'I':

Int_Data interne ;

cout < < "Immettere l'attribut (long interne) : ";

cin > > Int_Data ;

Arc_Name_Ptr = nouvel Int_Obj(Int_Data) ;

encore = faux ;

continu ;

maisons 'F ':

flotteur Float_Data ;

cout < < "Immettere l'attribut (flotteur) : ";

cin > > Float_Data ;

Arc_Name_Ptr = nouveau Float_Obj(Float_Data) ;

encore = faux ;

continu ;

défaut :

encore = rectifiez ;

continu ;

}

== de}while(again vrai) ;

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

}