Discussion :

[Kerozhaine]

Bonjour à tous!

Actuellement j'ai un projet d'études à développer en C sous VS9, qui consiste a implémenter le jeu Boogle (en résumé: recherche de mots valides dans une matrice n*n de lettres, en fonction d'un dictionnaire (construit a l'aide de la lecture d'un .txt) dans lesquels les mots valides sont contenus sous la forme d'un arbre lexicographique, puis affichage des mots valides a l'issue de la recherche )
On doit donc implémenter le dictionnaire sous la forme d'un arbre. Actuellement, (pour cette "partie dictionnaire"), j'ai 2 fonctions, DictionnaryCreation qui me lit le fichier .txt et place chaque mot dans un buffer (qu'on utilisera pour remplir l'arbre) et qui me renvoie un pointeur vers une structure t_dico, que la fonction a préalablement initialisé (j'ai choisi, pour la racine de l'arbre lexicographique, de faire pointer la racine du dictionnaire vers un tableau contenant 26 t_nodes qui contiennent les lettres du dictionnaires, pour ainsi creer 26 "sous-arbre" ( j'ai un doute sur l'exactitude du terme ) un pour les mots qui commencent par 'a', un pour ceux commencant par 'b', ect .. )
J'ai codé le gros de cette fonction qui a l'air de marcher puisqu'elle me renvoie bien un t_dico* avec ses champs correctement initialisés. Néanmoins dans la version finale du code, DictionnaryCreation est censé appeler la fonction Dictionnary_AddWord(t_node (*racine)[26],const char * mot) qui aura le role d'inserer chaque mot dans le dictionnaire.
Neanmoins lorsque je tente d'acceder aux cases de racine, je m'apercois que seules 11 des 26 cases sont correctement transmise(donc bien initialisées) lors de l'appel a Dictionnary_AddWord
Malgré une bonne journée passer a essayer de cerner l'erreur au debugger, je n'arrive pas a trouver pourquoi dans ce cas seulement 11 des cases sont correctement transmises lors de l'appel. J'ai tenté de verifier les malloc contenus dans Dictionnary_Creation, j'ai modifié les arguments de AddWord (à la base je voulais prendre un t_dico* pour aller chercher sa racine), et j'ai tenté plusieurs syntaxes, je n'arrive vraiment pas a cerner le probleme ( meme mon prof s'est penché dessus vite fait et n'a pas su me dire.)

Si quelqu'un pouvait me donner des pistes d'explications ce serait parfait pour continuer à avancer

Merci d'avance ! Je peux fournir le projet en .zip au besoin.

Voici les structures et le code associé :
dico.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef DICTIONARY_H
#define DICTIONARY_H
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include "node.h"
 
 
/* ************** DEFINITION STRUCTURE *********************** */ 
typedef struct
{
  t_node* racine;
  int nb_words;
  int nb_nodes;
}t_dico;
 
/* ************** FONCTIONS *****************************/
t_node* JumpDownTree(t_node* Tracker);
 
t_dico* DictionaryCreation(const char* Filename);
 
void Dictionary_AddWord(t_node (*racine)[26],const char * mot);

La structure node definie par node.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
typedef struct t_node
{
  char value;
  bool is_terminal;
  struct t_node ** childs;
	char nb_childs;
}t_node;

dico.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
#include <stdio.h>
#include <stdlib.h>
#include "dictionary.h"
 
t_node* JumpDown(t_node* Tracker)
{
	return (t_node*)Tracker->childs;
}
 
// TESTER approcher avec un t_node*[26]
void Dictionary_AddWord(t_node (*racine)[26],const char * mot)
{
	/* Initialisation variables locales*/
	char* buf=NULL;
	char index=0;
	t_node* tracker=NULL; /* tnode ** ??? */
 
 
	/* Test de la validite/existence de la chaine d'entree*/
	if (mot==NULL)
	{printf("The input string value of AddWord is NULL\n");
	return;}
 
	for (int i=0;i<26;i++)                                                             /* PRINTF DE DEBUG */
	{
		printf("%c",racine[i]->value);
	}
	/* Stockage du mot dans le buffer */
	buf=(char*)mot;
 
	/* Cette boucle va parcourir tout le mot et va creer une cellule de l'arbre pour chaque caractère */
	while(*buf != '\0')
	{
		// J'ai retiré le code execute par le while car pas necessaire dans le cadre de mon soucis :) 
	}	
 
}
 
 
 
 
t_dico* DictionaryCreation(const char* Filename)
{
	char buffer[50];
	/* Ouverture + verification ouverture*/
	FILE* f = fopen(Filename,"rt");
	if (f==NULL)
	{	printf("erreur ouverture dico.txt");
	return NULL;}
 
	/* Allocation de dico + verification allocation */
	t_dico* Dico= (t_dico*)malloc(sizeof(t_dico*));
	if (Dico == NULL)
	{	printf("erreur allocation dico\n");
	return NULL;}
 
		/* Initialisation Dico */
	Dico->nb_nodes=0;
	Dico->nb_words=0;
	Dico->racine=(t_node*)malloc(26*sizeof(t_node));
	if (Dico->racine == NULL)
	{
		printf("Erreur malloc dico->racine\n");
		return NULL;
	}
	/* recherche nombre de mots du fichier txt*/
	fseek(f,0,SEEK_SET);           // placement du curseur au debut du fichier
	fscanf(f,"%s",buffer);				//lecture/stockage dans buffer
	Dico->nb_words=atoi(buffer);	// conversion en int atoi()
	while(fgetc(f)!='\n');        // passage a la ligne suivante
 
 
	/* Creation de la racine de Dico */
	t_node racine[26];				// La racine est un tableau de 26 elements t_node 
	for(int i=0;i<26;i++) 		//qui consitutuera le debut d'arbre 
	{racine[i].value='a'+i;		// pour chaque lettre de début 
	 racine[i].childs=NULL;
	 racine[i].nb_childs=0;
	 racine[i].is_terminal=true;}
 
	/* Stockage de la racine dans dico*/
 
 
		Dico->racine=(t_node*)racine;
 
	/* Debut lecture mots et appel de AddWord pour construire les noeuds */
	for(int i=0;i<=Dico->nb_words;i++)
	{
		fscanf(f,"%s",buffer);
		//Dictionary_AddWord(Dico,buffer);
		while(fgetc(f)!='\n');
	}
	//printf("A priori ok \n ");
 
 
	if(fclose(f)!=0)
	{printf("erreur fermeture dico.txt\n");}
 
	return Dico;
}

Actuellement mon main de test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
void main()
{
        t_dico* Dico =DictionaryCreation("dico.txt");            //FONCTION correcte, renvoie et initialise correctement une structure Dico avec sa racine qui pointe vers un tableau de 26 t_nodes	 
        Dictionary_AddWord((t_node(*)[26])Dico->racine,test); // probleme A L'INTERIEUR de la fonction 
}

[Matt_Houston]

Dans le main tu cast un champ de type t_node * (pointeur sur t_node) vers t_node(*)[26] (pointeur sur tableau de 26 t_node), je ne vois pas comment ça peut bien se passer.

Lorsque le compilateur râle, ce n'est pas pour la forme. On ne cast pas à la légère. Retire tous les casts (il y en a d'autres) et compile avec tous les avertissements ; -std=c11 -pedantic -Wall -Wextra -Wconversion -Wwrite-strings, par exemple.