bon j'aimerais savoir comment définir un type récursif en ada. j'ai essayé :  
 
type B_arbre is record
 B_vide : boolean ; -- indique si l'arbre est vide
 etiquette : string(1..26) ; -- si l'arbre n'est pas vide il est composé d'une étiquette
 B_arbre_gauche : B_arbre ; -- et d'un sous arbre gauche
 B_arbre_droit : B_arbre ; -- et d'un sous arbre droit  
end record ;
 
mais il m'indique que B_arbre n'est pas un sous type (ce qui est quand même logique).

 
declare ton type avant
 
type B_arbre;
type B_arbre is record
 B_vide : boolean ; -- indique si l'arbre est vide
 etiquette : string(1..26) ; -- si l'arbre n'est pas vide il est composé d'une étiquette
 B_arbre_gauche : B_arbre ; -- et d'un sous arbre gauche
 B_arbre_droit : B_arbre ; -- et d'un sous arbre droit  
end record ;

[jfdsdjhfuetppo]--Message édité par DLR--[/jfdsdjhfuetppo]

négatif ça marche tjrs pas. j'obtiens exactement le même message d'erreur. je me demande si on peut déclarer des types récursifs en ada. quelqu'un sait ?
 
voila le message que j'obtiens :  
--------------------Target: Win32 (Intel) Debug--------------------
principale: Error: line 9 col 19 LRM:3.2.2(8), The name does not resolve to a subtype mark, Continuing  
 
principale: Error: line 10 col 18 LRM:3.2.2(8), The name does not resolve to a subtype mark, Continuing  
 
Front end of ..\fichier\principale failed with 2 errors.
Tool execution failed.

c'est normal que tu puisse pas !
ca boufferait tout la mémoire d'un coup !
 
il faut passer par des pointeurs pour ce genre de trucs. en ADA, les pointeurs ca se dit "access".
 
 
en gros c'est un truc comme ca (l'ada ca fait longtemps) :
type B_arbre;
type arbre is access B_arbre;
 
type B_arbre is record  
  etiquette : string(1..26) ;  
  arbre_gauche : arbre;
  arbre_droit : arbre;  
end record ;
 
remarque : t'as plus besoin du booléen qui dit si l'arbre est vide. Un arbre vide, c'est un arbre dont la valeur est null (pointeur null)

si mes souvenirs sont bons, il faut déclarer le type access en private pour des raisons dont je n'arrive plus à me souvenir

d'après ce que je viens de lire sur un site y'a pas besoin de déclarer en private. en tout cas merci !! on a pas encore vu ça en ada donc je vais bien m'amuser moi ! je vais réserver toute ma nuit la dessus !!

si tu connais déjà le fonctionnement des pointeurs en C ou un autre langage, c'est pareil. Par contre, si tu débute la dessus, tu vas en chier !!!! )
 
remarque : c'est étonnant que tu aies besoin de faire un arbre si tu n'as pas encore vu les pointeurs ...
 
autre remarque : le private n'est pas obligatoire, mais il me semble que c'est mieux de le mettre ...
en fait, je crois que c'est plutot sur la structure (le B_arbre) qu'il fut mettre private afin d'empecher l'utilisateur de ce type d'utiliser directement le type : il faut l'obliger à passer par des méthodes gérant l'arbre.
ex : une méthode fils_gauche(a : in arbre) : arbre, etc ...
 
derniere remarque : tin ! comment ca me fait bizare de reparler de l'ADA ! ca fait 3 ans que j'en ai pas fait !

[jfdsdjhfuetppo]--Message édité par benou--[/jfdsdjhfuetppo]

bon ça avance doucement mais surement ce programme mais étant donné qu'on commence juste avec les arbres (un seul cours en amphi) le projet s'annonce très délicat. c à rendre dans 10 jours donc c dure. donc besoin d'un peu d'aide sur ces  arbres !!
 
bon voila ma procédure :  
 
procedure traiter_mot (mot_chainé : in chaine ; Unarbre : in out arbre ; position : boolean) is
begin
 if position = false then
  traiter_sous_arbre_droit(unarbre) ;  
 else
  if mot_chainé(1) = unarbre.etiquette then
   traiter_sous_arbre_droit(unarbre) ;  
  else
   if arbre.arbre_droit.etiquette > mot_chainé(1) then
    null;
   elsif arbre.arbre_droit.etiquette = ' ' then -- si arbre vide
    null ;
   else  
    null ;
   end if;
   
  end if ;
 end if ;
end traiter_mot ;
 
avec les types :  
 
-- définition d'un sous arbre dont l'ascendant direct de la racine du sous arbre est une unique lettre (par exemple a) ;  
type arbre_sous_lettre ;
type arbre_secondaire is access arbre_sous_lettre;
type liste_de_mot is array (1..100) of string(1..26) ; -- 100 mots max par listes.
type arbre_sous_lettre is record  
  etiquette : integer ; -- longueur du mot ;  
  arbre_gauche : liste_de_mot ;
  arbre_droit : arbre_secondaire;  
end record ;
 
-- définition du type arbre contenant les feuilles avec une unique lettre (par exemple a) et les sous arbres descendant ;
type arbre ;
type sous_arbre is access arbre ;
type arbre is record  
 etiquette : character := ' ' ; -- l'espace sera considéré comme une étiquette vide dans le traitement du mot.
 arbre_gauche : arbre_sous_lettre ;
 arbre_droit : sous_arbre ;
end record ;
 
et j'ai droit comme erreur :  
 
--------------------Target: Win32 (Intel) Release--------------------
principale.ada: Error: line 5 col 6 LRM:4.1(7), Prefix is not an array, subtype, or callable entity, continuing  
 
principale.ada: Error: line 8 col 13 LRM:4.1.3(5), No possible interpretation for selected component arbre_droit, Ignoring future references  
 
principale.ada: Error: line 8 col 37 LRM:4.1(7), Prefix is not an array, subtype, or callable entity, continuing  
 
principale.ada: Error: line 10 col 16 LRM:4.1.3(5), No possible interpretation for selected component arbre_droit, Ignoring future references  
 
Front end of ..\fichier\principale.ada failed with 4 errors.
Tool execution failed.
 
en fait j'ai du mal à comprendre comme ça marche les arbres en ada. j'ai fait ça l'année dernière en caml et c'était beaucoup beaucoup plus facile tandis que là l'histoire des pointeurs et tout ça c un peu vague pour moi.

J'y comprend rien à ton truc. Déjà c'est pas un arbre !
un arbre c'est récursif :
un arbre c'est :  
 - soit vide
 - soit une structure composée d'une valeur et de deux arbres.
 
ca ne correspond pas du tout à ce que tu as fait comme type.
 
J'y comprend rien !

bah en fait j'ai un un arbre principal du type ARBRE qui est composé d'une valeur (un caractère) et qui se décompose en deux sous arbre :  
le sous arbre gauche sera un nouveau type d'arbre (du type Arbre_sous_lettre).
le sous arbre droit sera du type ARBRE.
 
le type du sous arbre gauche (arbre_sous_lettre) aura comme sous arbre_gauche une liste de mot et comme sous arbre droit un arbre de type (arbre_sous_lettre).

je t'envoie un E-mail avec ma strucure d'arbre au format word.

euh c vrai que j'ai pas précisé ce que je voulais faire. le but de ce prg est d'afficher à l'écran sous forme de liste classé par ordre alphabétique ou par longueur tous les mots contenus dans un fichier en évitant les doublons.  
je pensais utilisé une structure s'approchant d'un arbre afin d'accéder plus rapidement à des mots.  
bref pour prendre un exemple : le mot 'babar'
il compare la première lettre du mot avec l'étiquette de l'arbre qui est initialisé à 'a' par défaut. la lettre étant différente, il s'enfonce dans le sous arbre_droit et compare l'étiquette du sous arbre droit avec la première lettre du mot. quand la première lettre du mot est égale a l'étiquette du  sous arbre alors on s'enfonce dans le sous arbre gauche du sous arbre courant. dans le sous arbre gauche on compare la longueur de mot avec l'étiquette du sous arbre. si c plus grand on s'enfonce dans le sous arbre droit et ainsi de suite jusqu'à trouver une étiquette égale à la longueur du mot. quand on trouve l'étiquette on insére le mot dans le sous arbre gauche du sous arbre courant qui est en fait une liste de mot rangé alphabétiquement.
 
et pareil pour tous les mots d'un texte.  
euh je sais pas si c clair mon explication. je suis pas très doué pour expliquer  

'fo utiliser le type access (pointeur) j'avait oublie ca

purquoi tu fais pas un arbre tout con ?
 
arbre : caractère + fils_gauche + fils_droit.
 
ex d'arbre qui contient les mots aac, aba, aaa, bbba, bbb

   
le principe c'est que pour lire un mot : tu pars de la racine, quand tu descend à gauche tu ajoute la lettre du noeud que tu viens de quitter, quand tu pars à droite tu ne fais rien, qui tu est sur un noeud qui n'a pas de fils gauche, c'est la fin d'un mot.
 
Je suis pas sur que ca tienne parfaitement debut, mais il doit y avoir moyen de s'en tirer avec ce genre de structure ...

ouais il manque un truc dans mon arbre : la gestion des fins de mot. ex pour stocket : aa et aaa.
Pour faire ca simplement, il faut utiliser un caractère comme délimiteur de fin de mot, par exemple la fin de ligne (\n)
 

comme ca, l'arre doit être capable de stocker tous les mots que tu veux, et c'est une structure plus simple que celle que tu avais faite !

euh j'ai oublié de précisé quelque chose. la structure d'abre est intéressante mais je suis obligé d'avoir une liste car dans cette liste qui contient des mots, elle contiendra aussi un "pointeur" qui pointera vers une ligne d'une autre sous liste contenant toutes les occurences de tous les mots avec les lignes et les colonnes ou ils apparaissent. ça donne donc :  
 
le premier tableau:  
mot  |  pointeur                  
aaa  |  1                                            
aab  |  4
dda  |  5
 
le second tableau
ligne | colonne | occurence_suivante du mot
  1   |   10    |       2                 ---> concernera 'aaa'
  3   |   15    |       3                 ---> concernera 'aaa'
  4   |   1     |       7                 ---> concernera 'aaa'
  10  |   52    |       0                 ---> concernera 'aab'
  15  |   2     |       10                ---> concernera 'dda'
 
 
l'occurence_suivante égale à 0 signifie qu'il n'y a pas d'autres occurence pour ce mot
 
 
c pas moi qui est pondu cette strucure mais le prof...

Ben tu as juste à faire une strcture conditionnelle (je ne sais plus comment ca se fait en Ada).
Dans le cas du noeud qui correspond à une fin de mot, la strcuture, à la place de contenir un caractère et 2 sous arbres, elle contiendra juste un pointeur vers ta 2e liste.

je vais continuer avec ma structure en utilisant des listes et des arbres. l'idée de mettre tout en arbre est intéressant (très même) mais j'ai pas encore les compétences pour le faire (déjà ce que je fais c limite au programme) et en plus l'utilisation des listes ne sera pas du luxe pour revoire un peu mes cours !! et en plus j'ai trouvé d'ou provenait mes erreurs (une erreur stupide !!!!).  
en tout cas merci et je pense que j'aurais peut être encore besoin de ton aide (on sait jamais). au fait tu as utilisé souvent l'ada dans tes études ou dans ton travail ???

Juste un point de detail:
Ce dont vous parlez, ce sont des arbres binaires, il me semble.
 
Pour moi, c'est surtout la structure de donnée d'un noeud d'un arbre qui est importante:
 
en C:
typedef struct NoeudArbreT {
struct NoeudArbreT *pere;
struct NoeudArbreT *frereprecedent;
struct NoeudArbreT *freresuivant;
struct NoeudArbreT *premierfils;
} NoeudArbreT;
 
type de donnée de base, sur lequel on peut rajouter ce dont on a besoin: Un pointeur sur une structure ad-hoc ListeProprietesNoeudArbreT qui contiendra les infos que l'on veut associer a chaque noeud de l'arbre.
 
Pour optimiser certains algos, on peut modifier la structure precedente comme suit:
 
typedef struct NoeudArbreT {
struct NoeudArbreT *pere;
struct NoeudArbreT *frereprecedent;
struct NoeudArbreT *freresuivant;
struct NoeudArbreT *premierfils;
struct NoeudArbreT *dernierfils;
unsigned int nbfils;
} NoeudArbreT;
 
Avec ce genre de structure, un arbre n'est que la donnée d'un sommet privilegié, son sommet:
typedef NoeudArbreT *ArbreT;  (et l'arbre vide correspond alors au cas ou le pointeur est null).
 
Donc si on transpose ca en ADA, (aux erreurs pres, plus de 12 ans que j'y ai plus touché) ca devrait donner:
 
type NoeudArbreT;
type PtrNoeudArbreT is access NoeudArbreT;
type ListeProprietesNoeudArbreT;
type PtrListeProprietesNoeudArbreT is access ListeProprietesNoeudArbreT;
 
type NoeudArbreT is record  
 pere           : PtrNoeudArbreT ;  
 frereprecedent : PtrNoeudArbreT ;  
 freresuivant   : PtrNoeudArbreT ;  
 premierfils    : PtrNoeudArbreT ;  
 dernierfils    : PtrNoeudArbreT ;
 nbfils         : integer ;  
 proprietes     : PtrListeProprietesNoeudArbreT;
end record ;
 
type ArbreT is acces NoeudArbreT;
 
A+,

bha ouais mais c'est super chiant à manipuler ton arbre : des que tu bouge un noeud, t'as plein de pointeurs à mettre à jours un peu partout !
 
un ch'ti arbre binaire ca suffit pour ce problème.
 
LordAnkou > si tu veux continuer sur ta structure, vas-y mais je la trouve assez complexe. Tu vas en chier pour la manipuler.
bon courage !

benou a écrit a écrit : bha ouais mais c'est super chiant à manipuler ton arbre : des que tu bouge un noeud, t'as plein de pointeurs à mettre à jours un peu partout !   un ch'ti arbre binaire ca suffit pour ce problème.   LordAnkou > si tu veux continuer sur ta structure, vas-y mais je la trouve assez complexe. Tu vas en chier pour la manipuler. bon courage !

Arf! Y'a rien de plus facile.
Et des que tu bouges un noeud, tu bouges le sous arbre associé.
Avec ce type de structure, une descente recursive par largeur ou profondeur d'abord s'ecrit tres aisement.
A+,

bon voila je déclare les type suivant :  
 
-- définition d'un sous arbre dont l'ascendant direct de la racine du sous arbre est une unique lettre (par exemple a) ;  
type arbre_sous_lettre ;  
type arbre_secondaire is access arbre_sous_lettre;  
type liste_de_mot is array (1..100) of string(1..26) ; -- 100 mots max par listes.  
type arbre_sous_lettre is record  
etiquette : integer ; -- longueur du mot ;  
arbre_gauche : liste_de_mot ;  
arbre_droit : arbre_secondaire;  
end record ;  
 
-- définition du type arbre contenant les feuilles avec une unique lettre (par exemple a) et les sous arbres descendant ;  
type arbre ;  
type sous_arbre is access arbre ;  
type arbre is record  
etiquette : character := ' ' ; -- l'espace sera considéré comme une étiquette vide dans le traitement du mot.  
arbre_gauche : arbre_sous_lettre ;  
arbre_droit : sous_arbre ;  
end record ;  
 
 
-------------------------------------------------  
 
le problème c par exemple quand je lance la procédure  
 
traiter_mot(mot_chainé, unarbre.arbre_droit, false, unAutreArbre) ;  
 
dont les types sont :  
 
procedure traiter_mot (mot_chainé : in chaine ; Unarbre : in out arbre ; position : boolean ; unAutreArbre : in out arbre_sous_lettre ) ;  
 
il me marque :  
 
principale.ada: Error: line 72 col 5 LRM:6.4.1(3), Parameter mismatch in call, type mismatch for param 2, Unarbre: arbre (found sous_arbre).  
 
 
or normalement Unabre.arbre_droit est bien du type sous_arbre MAIS il a accès à arbre donc il devrait pas me marquer ce message. quelqu'un a une idée ???
 
 
------------------
 
N.B : le problème c'est que si j'utilise un arbre binaire je vois pas comment l'organiser. à l'étiquette on met une lettre mais à droit on mettre quoi ? et à gauche ? parce que ensuite faut fait le traitement par ordre alphabétique avant de l'afficher.

bon j'ai résolu mon problème ci dessous mais il m'en reste encore et là je vois pas :
 
function supprime_mot_chainé(lachaine : chaine ; mot_chainé : chaine) return chaine is  
indice : integer ;
begin
 for compteur in mot_chainé.longueur_de_la_chaine..lachaine.longueur_de_la_chaine loop
  indice := compteur - (mot_chainé.longueur_de_la_chaine) ;
  lachaine.caractère(indice) := lachaine.caractère(compteur) ;
 end loop ;
 return lachaine ;
end supprime_mot_chainé ;
 
j'obtiens une erreur sur "lachaine.caractère(indice) := lachaine.caractère(compteur) ;"
 
il me marque :  
liste_et_chaine.adb: Error: line 49 col 12 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment
 
chaine est du type :  
max_longueur_mot: constant := 255 ; -- longueur maximum d'un mot
type chaine is record
   caractère : string(1..max_longueur_mot)  ;
   longueur_de_la_chaine : integer := 0 ;
end record ;
 
 
en plus c une erreur qui se répète sur 19 lignes dans d'autres procédures donc ça provient pas de la procédure ou de la fonction. bref je rame encore    
 
sinon cette erreur ça veut dire quoi :  
principale.ada: Error: line 58 col 43 LRM:6.4.1(5), If the mode is IN OUT or OUT, the actual shall be a name that denotes a variable, Continuing

bha avec n'importe quel structure d'arbre ...  Pile ou File, il faut choisir

 
si je ne me trompe pas, il faut que tu déclare la variable laChaine de ta prodérure en mode in out, si qui signifie que ta méthode aura le droit de modifier le paramètre que tu lui passes. Par défaut, le mode doit être in, ce qui expliquerait l'erreur de compilation
 
d'après mes très faibles et lointains souvenirs, ca se fait comme ca :  

 
remarque : tu auras peut-être besoinde mettre laChaine en mode in out ... je suis pas sûr

 
pour moi c'est parce que tes types sont mal déclarés que tu as des problèmes sur ce genre de trucs :  
ton type arbre devrait être le pointeur, pas la structure !

type arbre_record is private;  -- (je suis pas sur de la syntaxe du private, et si ca t'embete, tu n'est pas obligé de le mettre private)
type arbre is access arbre_record;  
type arbre_record is record  
   etiquette : character := ' ' ;  
   arbre_gauche : arbre_sous_lettre  ;  
   arbre_droit : arbre;  
end record ;  
 
C'est bien plus logique comme ca ! comme ca, unArbre->arbre_droit est bien de type arbre !

ce problème et corrigeait mais j'ai toujours plein d'erreur de partour. des trucs du style :
 
--------------------Target: Win32 (Intel) Release--------------------
principale.ada: Error: line 61 col 43 LRM:6.4.1(5), If the mode is IN OUT or OUT, the actual shall be a name that denotes a variable, Continuing
 
principale.ada: Error: line 64 col 44 LRM:6.4.1(5), If the mode is IN OUT or OUT, the actual shall be a name that denotes a variable, Continuing
 
principale.ada: Error: line 87 col 4 LRM:6.4.1(3), Parameter mismatch in call, type mismatch for param 2, liste: uneListe (found liste_de_mot).
principale.ada: Error: line 93 col 48 LRM:5.2(4), Type mismatch in assignment statement, continuing  
 
Front end of ..\fichier\principale.ada failed with 4 errors.
Tool execution failed.
 
---------------------
--------------------Target: Win32 (Intel) Release--------------------
liste_et_chaine.adb: Error: line 49 col 12 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 57 col 6 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 75 col 20 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 76 col 9 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 84 col 26 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 88 col 30 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
liste_et_chaine.adb: Error: line 91 col 31 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
Front end of ..\fichier\liste_et_chaine.adb failed with 7 errors.
Tool execution failed.
 
 
avec par exemple pour une ligne de code :
lachaine.caractère(indice) := lachaine.caractère(compteur);

je t'ai  donné la réponse : paramètre de procédure en mode in  out !

oups oui ! désolé !!!
 
mais l'erreur sur  
liste_et_chaine.adb: Error: line 49 col 12 LRM:5.2(5), The target of an assign statement must be a variable, Returning illegal assignment  
 
 
t'as une idée ?

encore une fois, je te dis que je pense que l'erreur viens du fais que tu passes tes paramètres en mode in !
 
tu affectes une valeur au pâramètre que tu passes à à une procédure. Pour que la modification puisse avoir lieu, il faut que ton paramètre soit en mode écriture (out).

le problème c que c une fonction donc y'a pas de paramètres out.  
 
function supprime_mot_chainé(lachaine : chaine ; mot_chainé : chaine) return chaine is  
indice : integer ;
begin
 for compteur in mot_chainé.longueur_de_la_chaine..lachaine.longueur_de_la_chaine loop
  indice := compteur - (mot_chainé.longueur_de_la_chaine) ;
  lachaine.caractère(indice) := lachaine.caractère(compteur);
 end loop ;
 return lachaine ;
end supprime_mot_chainé ;

et ben voila le problème : tu essayes de modifier le paramètre d'une fonction. Et en Ada, t'as pas le droit !
 
si tu veux faire ca, tu fais une procédure !

bon j'ai encore changé la structure et ça va mieux sauf que là j'ai une erreur un peu bizarre.
J'ai un paquetage "Liste_et_chaine" qui utilise le paqutage "arbre" et "arbre" utilise le paquetage "liste_et_chaine". Ors quand je compile j'obtiens le message suivant pour liste_et_chaine :
 
--------------------Target: Win32 (Intel) Debug--------------------
liste_et_chaine.ads: Error: line 2 col 6 Unit depends on source file ..\fichier\arbre.ads which contains errors
 
Front end of ..\fichier\liste_et_chaine.ads failed with 1 error. (0 Warnings)
Tool execution failed.
 
 
tandis que pour arbre j'obtiens :
 
--------------------Target: Win32 (Intel) Debug--------------------
arbre.ads: Error: line 1 col 5 Unit depends on source file ..\fichier\liste_et_chaine.ads which contains errors
 
Front end of ..\fichier\arbre.ads failed with 1 error. (0 Warnings)
Tool execution failed.
 
 
 
bref il m'indique qu'il ne peut pas compiler le paquetage parce qu'il y a une erreur dans le paquetage qu'il utilise et vice versa !!!!!