Notion des arbres de syntaxe abstraite

Bonsoir,

Je suis en train de m'entrainer sur les AST , j ai reussi a faire une fonction qui cree
l'arbre puis initialise fils_g et fils_d
cependant je ne comprend pas comment chainee le tout , en creant un noeud dans un noeud .
Par ailleurs, est t-il possible d'avoir plusieurs structures ce chainant qui sont relies par "racine" , par exemple :

struct_tree --> struct_tree ---> Null
--> fils_g -->fils_g -> Null
--> fils_d -->fils_d --> Null

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

typedef struct s_tree t_tree; struct s_tree { char *cmd; struct s_tree *fg; struct s_tree *fd; };   t_tree *Add_Node(t_tree *tree_t, char *fg, char *fd) { tree_t->fg = malloc(sizeof(*tree_t->fg) * strlen(fg)); tree_t->fd = malloc(sizeof(*tree_t->fd) * strlen(fd));   if (tree_t->fg != NULL && tree_t->fd != NULL) { tree_t->fg = fg; tree_t->fd = fd; return (tree_t); } return (NULL); }   t_tree *create_tree(t_tree *tree_t, char *cmd) { t_tree *new_t;   new_t = malloc(sizeof(*new_t)); if (new_t != NULL) { new_t->cmd = cmd; new_t->fg = NULL; new_t->fd = NULL; return (new_t); } return (NULL); }

---

En esperant avoir ete clair ,
Cordialement

J'ai du mal à comprendre la question, mais les malloc() de Add_Node() sont complètement fantaisistes.

En faisant un peu de renommage, on s'y retrouve un peu plus (exemple : t_tree -> node_t ; char* fd -> char* cmd_fd). Et puis comme l'a dit Médinoc tes malloc sont mauvais.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

node_t* Add_Node(node_t *pere, char *cmd_fg, char *cmd_fd) { pere->fg = malloc(sizeof(node_t)) ; pere->fd = malloc(sizeof(node_t)) ;   if (pere->fg != NULL && pere->fd != NULL) { pere->fg->cmd = malloc(sizeof(char) * strlen(cmd_fg)); pere->fd->cmd = malloc(sizeof(char) * strlen(cmd_fd)); pere->fd->fd = NULL ; pere->fd->fg = NULL ; pere->fg->fg = NULL ; pere->fg->fd = NULL ;     strncpy (pere->fg->cmd , cmd_fg, strlen(cmd_fg) ) ; strncpy (pere->fd->cmd , cmd_fd, strlen(cmd_fd) ) ; return pere ; } return NULL ; }

---

Il faut que tu alloues les deux fils du père (2 premier malloc) mais également les chaines de caractères de ces deux fils (2 suivant).
Pour mieux découper ton programme tu pourrais ajouter une fonction "init_node(node_t* node, char* cmd)".
Tu pourrais également ajouter des vérifications pour voir si les fils de ton noeud ne sont pas déjà initialisés.

N'oublie pas de NULL-terminé tes chaines de caractères (finir par '\0').
Et pour finir, garde en tête que ton return n'est là que pour de l'ergonomie.

Je vous remercie pour vos reponses, je vais re-travailler un peu mon code ,
merci pour vos indications ,
Cordialement

Bonjour,

Apres quelques essai , j arrive a initialiser correctement mon premier arbre,
Maintenant je souhaite savoir comment faire pour descendre en profondeur.
Je Segfault lorsque je tente de cree un sous arbre en recursif dans la fonction create_arbre() ,
Merci de bien vouloir m eclairer ..
Cordialement

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

t_tree *fils_droit(t_tree *racine, char *droite) { racine->droite = malloc(sizeof(*racine->droite) * strlen(droite)); if (racine->droite != NULL) { racine->droite = droite; return (racine->droite); } return (NULL); }   t_tree *fils_gauche(t_tree *racine, char *gauche) { racine->gauche = malloc(sizeof(*racine->gauche) * strlen(gauche)); if (racine->gauche != NULL) { racine->gauche = gauche; return (racine->gauche); } return (NULL); }   t_tree *creation_arbre(t_tree *racine, char *mot, char *gauche, char *droit) { if (racine == NULL) { racine = allocate_tree(); racine->cmd = dupchaine(mot);   racine->gauche = fils_gauche(racine, gauche); racine->droite = fils_droit(racine, droit); } else if (racine != NULL) { if (racine->gauche == NULL) racine->gauche = creation_arbre(racine->gauche, mot, gauche, droit);   else racine->droite = creation_arbre(racine->droite, mot, gauche, droit); } return (racine);

---

1.
Déjà, ta création d'arbre, elle est censée faire quoi? Parser une ligne de commande (ou une fonction mathématique) pour en faire un arbre?
Ou elle est censée être appelée par la fonction qui fait ça?

2.
Tes mallocs sont toujours confus. Essaie de mieux décomposer ton code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

char * mystrdup(char const *input) { if(input == NULL) return NULL; else { char * ret = malloc(strlen(input) + 1); if(ret != NULL) strcpy(ret, input); return ret; } }   t_tree * CreerNoeud(char const *cmd) { t_tree * pNoeud = malloc( sizeof *pNoeud ); if(pNoeud != NULL) { pNoeud->cmd = mystrdup(cmd); pNoeud->fg = NULL; pNoeud->fd = NULL; } }

---

Ainsi, tes fonctions ressembleront plus à cela:

Code:

---

1 2 3 4 5

t_tree * AjouterFilsDroit(t_tree * racine, char const *cmd) { racine->fd = CreerNoeud(cmd); return racine->fd; }

---