II UNIVERSITÉ DES ÉTUDES DE
ROME
Massif de roche Vergata
Cours de
Bases de l'informatique II
prof. Giovanni Cantone
Le Grafi Oriente À Vous
1) introduction
2) définitions
3) représentation du
graphique abstrait de données
) à l'endroit objecte la
base
i. ARC_NODE
II. ARC_LIST
III. VERTEX_NODE
iv. GRAPHIQUE (Vertex_List)
b) Description et exécution
du polimorfismo
i. ÉLÉMENT
II. INT_OBJ
III. CHAR_OBJ
iv. FLOAT_OBJ
c) développement
d'applicativo basé sur le GRAPHIQUE de classe
1) introduction
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.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.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()
{
}
/
/
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 ;
}
}
/
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 ;
}
}
}
/
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 ;
}
}
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 ;
}
/
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 ;
}
}
/
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.
/
# 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()
{
}
/
/
vide Vertex_Node::Display_Vertex()
{
Vertex_Attribute->Display() ;
if(Next_Vertex ! = 0)
cout < < "," ;
autrement
cout < < endl ;
}
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.
//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()
{
}
/
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 ;
}
}
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 ;
}
}
}
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 ;
}
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 ;
}
/
//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 ;
}
/
/
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 ;
}
/
/
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 ;
}
}
}
/
/
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 ;
}
}
/
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 ;
}
}
/
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.
//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"
/
/
Element::Element()
{
strcpy(My_Class, "élément") ;
}
Element::~Element()
{
}
char * Element::Get_Class()
{
My_Class de retour ;
}
/
vide Element::Display()
{
}
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.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()
{
}
/
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 ;
}
/
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())) ;
}
}
/
# 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") ;
}
/
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())) ;
}
}
/
/
vide Char_Obj::Display()
{
cout < < valeur ;
}
//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()
{
}
/
/
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 ;
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<< " | |\n ";
cout<< " | |\n ";
cout<< " | |\n ";
cout<< " | |\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) ;
}
/
Insert() vide
{
Set_Source_Vertex_Name() ;
My_Graph->Insert(Source_Name_Ptr) ;
}
/
/
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) ;
}
/
/
Display() vide
{
My_Graph->Display_Graph() ;
}
/
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 ;
}
/
Number_Of_Arcs_In() vide
{
le cout < < "dans le graphique est présent" ;
cout < < My_Graph->Number_Of_Arcs_In() ;
cout < < "voûtes." < < endl ;
}
/
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) ;
}
/
bon y_Vertex() vide
{
Set_Source_Vertex_Name() ;
My_Graph->Remove_Vertex(Source_Name_Ptr) ;
}
/
/
bon y_Graph() vide
{
My_Graph->Clear() ;
}
/
/
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)) ;
}
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" ;
}
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" ;
}
/
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" ;
}