Discussion :

[SweetLeaf]

Bonjour !
Je voudrais récupérer les données d'un fichier texte dans un tableau.
J'ai deja essayer fgets mais cela ne fonctionne pas.

Ensuite j'aurais voulu éclater une chaine de caractère pour traiter caractère par caractère. j'ai deja tester substr et strcpy mais je ne sais pas m'en servir.

Si quelqu'un aurait une solution a mon probleme je suis preneur !
Merci et bonne journée !!

[diogene]

Je voudrais récupérer les données d'un fichier texte dans un tableau.
J'ai deja essayer fgets mais cela ne fonctionne pas.

Si tu ne montres pas le code qui te pose problème, on ne pourra pas t'aider.

[Bobsleigh]

Tu dois mal utiliser fgets. Cette fonction est normalement assez utile pour mettre du texte à partir d'un fichier dans un tableau. Un exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
FILE * monFichier;
char tableau[10];
 
monFichier = fopen("nomDuFichier", "r");
fgets(tableau, 10, monFichier); 
/*Arguments: 1)Pointeur sur le tableau à remplir 
2)Nb de charactères maximal à entrer(incluant le caractère de fin de string)
3)Pointeur sur le fichier*/
fclose(monFichier);

On met donc les 9 premiers caractères du fichier nomDuFichier dans tableau[10] et le caractère de fin de string.

Il faut savoir que fgets arrête de lire s'il rencontre une nouvelle ligne ou la fin de ton fichier. C'est en général la façon la plus simple de récupérer du texte dans un fichier. Fait une recherche sur la fonction fgets si jamais tu veux apprendre à bien la manier. Si tu veux lire de façon plus spécifique, il faut que tu détailles plus ce que tu cherches à faire pour qu'on t'aide.

[SweetLeaf]

Voici la fonction qui me pose problème:

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
void chargeDico(char* nom, char TabD[], int longD)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    int i=0;;
 
    fichier = fopen(nom, "r");
 
    if (fichier != NULL)
    {
        printf("%d\n",longD);
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            TabD[i]=chaine;
            i++;
            printf("%s\n",TabD[i]);
        }
 
        fclose(fichier);
    } 
}

Elle est sensée lire une ligne de mon fichier passé en paramètre et me la collé dans mon tableau. Malheureusement, dans mon tableau je ne récupère que des lignes qui ne veulent rie dire genre, "&#°^[".

[Thierry Chappuis]

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
void chargeDico(char* nom, char TabD[], int longD)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    int i=0;;
 
    fichier = fopen(nom, "r");
 
    if (fichier != NULL)
    {
        printf("%d\n",longD);
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            TabD[i]=chaine;
            i++;
            printf("%s\n",TabD[i]);
        }
 
        fclose(fichier);
    } 
}

Pourquoi TabD est-il un tableau de caractères au lieu d'être un tableau de tableaux de caractères? De plus, la ligne

Code :

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

TabD=chaine;

ne fait pas ce que tu penses. Pour copier une chaîne, utilise strcpy(). Pour cela, il faut que TabD soit un tableau de chaines de caractères.

Thierry

[SweetLeaf]

Merci pour vos reponse mais j'ai toujours rien compris...
Pour faire simple, comment je peux faire pour récupérer dans une variable le résultat d'un fgets ? ( la variable doit pouvoir changer a chaque ittération, genre TabD[1] puis TabD[2], etc.)

[Pouet_forever]

Tu peux jeter un oeil à la fonction strtol : http://www.linux-kheops.com/doc/man/.../strtol.3.html

Ou alors utiliser fscanf à la place de fgets

[SweetLeaf]

Le problème c'est que je veux récupérer une chaine pas un int. A moins que je puisse remettre le int en char par la suite, mais bon c'est pas top pour la rapidité d'exécution...

Pour fscanf, je n'ai réussi qu'a récupérer des caractères et non des chaines... La fonction plante quand on met "%s".

[diogene]

Reprenons.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void chargeDico(char* nom, char TabD[], int longD)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
  ....
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            TabD[i]=chaine;
            i++;
            printf("%s\n",TabD[i]);
        }

Comme le dit Thierry , TabD est un tableau de char donc quelque chose qui est apte à stocker UNE chaine de caractères, pas plusieurs.

Si tu veux stocker plusieurs chaines, il faut avoir
- (1) un tableau de chaines donc un tableau de tableau de char
- (2) ou un tableau de pointeurs sur des chaines donc un tableau de pointeur sur des tableaux de char.
Le choix dépend du reste du code et de ce que tu veux faire exactement.

Dans le cas (1), TabD[i] est un tableau de char et il est de toute façon impossible d'écrire

Code :

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

TabD[i] = chaine;

puisqu'il est interdit d'écrire tableau = quelque chose.
Si on veut stocker la chaîne dans ce tableau, on écrira

Code :

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

strcpy(TabD[i], chaine)

Dans le cas (2) TabD[i] est l'adresse du tableau (et ce tableau doit effectivement exister) destiné à recevoir la ieme chaine. Quand tu fais

Code :

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

TabD[i] = chaine;

tu copies l'adresse du tableau chaine dans TabD[i]. Le compilateur sera d'accord, mais
- tous les éléments de TabD[i] contiendront la même adresse, celle de la toute dernière chaine lue sur le fichier
- cette adresse est celle d'un tableau local qui comme toute variable locale à une fonction est détruite en sortie de la fonction. Cette adresse est donc celle de quelque chose qui n'existe plus !
Il faut copier explicitement la chaine (et il faut que TabD[i] soit l'adresse d'un tableau qui existe avant cette copie) :

Code :

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

strcpy(TabD[i], chaine)

[SweetLeaf]

Euh, quand j'utilise

Code :

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

strcpy(TabD[i],chaine);

ca plante...
J'ai demandé à plusieurs potes de classes et ils ont le même problème...
Sauf certains qui utilisent des tableaux de listes, mais je ne comprend rien aux listes en c...

[SweetLeaf]

Est-ce que c'est tout simplement possible ??
Parce-que sinon je change totalement de méthode, j'ai encore le temps de changer, il me reste une semaine.

[diogene]

Peux-tu montrer le code tel qu'il est aujourd'hui pour que l'on sache bien d'où on part ( y compris le code de la fonction qui utilise chargeDico() et les déclarations des variables)?

[SweetLeaf]

Ca c'est mon fichier il y a tout dedans.

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#include <stdio.h>
#include <stdlib.h>
#define TAILLE_MAX 10000
 
 
 
//parcourt et affiche la grille
void parcoursGrille()
{
     int i=0; int j=0;
     char vC;
     FILE* FICHIER=NULL;
 
     FICHIER = fopen("grille.txt", "r+");
 
     if (FICHIER!= NULL)
    {
       for(i=0;i<15;i++)
         {
                        for(j=0;j<30;j++)
                        {
                                         fscanf(FICHIER, "%c", &vC);
                                         if (vC!='\n')
                                         {
                                                             printf("%c", vC);
                                         }
                        }
            printf("\n");
         }            
 
        fclose(FICHIER);
    }
}
 
 
 
int LongueurFichier(char* nom)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    long compte;
    fichier = fopen(nom, "r");
    compte =0;
    if (fichier != NULL)
    {
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            compte= compte +1;
        }
 
        fclose(fichier);
    }
    return compte;
}
 
void chargeDico(char* nom, char TabD[], int longD)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    char* mot;
 
    printf("%s\n",nom);
 
    fichier = fopen(nom, "r");
 
    if (fichier != NULL)
    {
        printf("%d\n",longD);
 
 
        while ( fgets(chaine,TAILLE_MAX,fichier) != NULL)  
        {  
            strcpy(mot,chaine);
            printf("chaine: %s\n",chaine);
            printf("lecture: %s\n",mot);
            system("PAUSE");
        } 
 
        fclose(fichier);
    }
}
/*
void chargeMot(char* nom, char TabM[], int longM)
{
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    int i=0;;
    
    fichier = fopen(nom, "r");
    
    if (fichier != NULL)
    {
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)
        {
            TabM[i]=chaine;
            i++;
        }
 
        fclose(fichier);
    }
}
 
void Recherche(char TabD[], int longD, char* TabM[], int longM, char TabR[])
{
     int i=0; int j=0; int length=0; int z=1; int k=0; int compte=0;
     char* lettre="";
     for(i=0;i<=longD;i++)
     {   
         //char mot[]= TabD[i];
         for(j=0; j<=longM; j++)
         {
             for(k=0;k<= strlen(TabD[i]);k++)
             {
                 strncpy(&lettre, &TabD[i], 5);
                 printf("ici :%c",lettre);
                 if(lettre==TabM[j])
                 {
                     compte++;
                     }
             }
             if(compte== strlen(TabD[i]))
             {
                 TabR[z]=TabD[i];
                 z++;
             }
         }
     }
}
*/
int main(int argc, char *argv[])
{
    int longD; int longM;
 
    parcoursGrille();
 
    system("PAUSE");
 
    longD = LongueurFichier("dico.txt");
 
    longM = LongueurFichier("mot.txt");
 
    char TabD[longD];
    //char TabM[longM];
    //char TabR[longD];
 
 
    //chargeDico("dico.txt", TabD, longD);
 
 
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    char* mot;
    long i=1;
 
    fichier = fopen("dico.txt", "r");
 
    if (fichier != NULL)
    {
        printf("%d\n",longD);
 
 
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL)  
        {  
            strcpy(mot,chaine);
            TabD[i]=mot;
            i++;
            system("PAUSE");
        } 
 
        fclose(fichier);
    }
 
 
 
    //chargeMot(mot, TabM, longM);
 
    //Recherche(TabD, longD, TabM, longM, TabR);
 
 system("PAUSE");
 return 0;   
}

[diogene]

Commentaires sur le main() (je n'ai gardé que la partie critique) :

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
int main(int argc, char *argv[])
{
....   
    char TabD[longD];
....    
    FILE* fichier = NULL;
    char chaine[TAILLE_MAX] = "";
    char* mot;
    long i=1;
....   
        while (fgets(chaine, TAILLE_MAX, fichier) != NULL)  
        {  
            strcpy(mot,chaine);
            TabD[i]=mot;
            i++;
        } 
....   
}

- le fgets lit une ligne et place le résultat dans un tableau de caractères chaine : Correct

- le strcpy() copie une chaine dans une autre. Ici la destination est un pointeur mot qui n'est pas initialisé par l'adresse du début d'un tableau. La destination n'est pas un tableau : Incorrect et plantage. Le compilateur doit râler parce que tu utilises une variable non initialisée.

- TabD[i]= mot. mot est une adresse (toujours non initialisée) type char *. TabD est un tableau de char donc tabD[ i] est un char. Cette expression équivaut symboliquement à char <- char *: Incorrect et le compilateur doit râler à cause de la conversion pointeur vers entier que cela implique.

Ce que tu veux faire : stocker les lignes dans un tableau. Il te faut un tableau de lignes. Chaque ligne est un tableau de char. Donc il faut un tableau de tableaux de char. Sur ce thème, plusieurs solutions sont possibles. En voici une :

Code :

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

1
2
3
4
5
6
7
    char TabD[NOMBRE_MAX_LIGNES][TAILLE_MAX];
    long i=0 ;// les indices commencent à 0
    while (fgets(chaine, TAILLE_MAX, fichier) != NULL)  
        {  
            strcpy(TabD[i],chaine);
            i++;
        }

Ici pas de problème : TabD[i] est un tableau de TAILLE_MAX char

[SweetLeaf]

Avec :

Code :

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

1
2
3
4
5
6
7
 char TabD[NOMBRE_MAX_LIGNES][TAILLE_MAX];
    long i=0 ;// les indices commencent à 0
    while (fgets(chaine, TAILLE_MAX, fichier) != NULL)  
        {  
            strcpy(TabD[i],chaine);
            i++;
        }

ca marche bien, mais juste pour un petit fichier. Pourquoi ?
Faut-il allouer de la mémoire comme j'ai vu dans certain tutoriel ?

[diogene]

ca marche bien, mais juste pour un petit fichier. Pourquoi ?

Bien sûr, tu es limité en nombre de lignes du fichier par la place réservée par le tableau (NOMBRE_MAX_LIGNES)

Faut-il allouer de la mémoire comme j'ai vu dans certain tutoriel ?

Si tu ne connais pas le nombre maximum de lignes du fichier avant exécution, il faudra en passer par l'allocation dynamique de tabD.
Mais j'ai vu que tu avais prévu de compter les lignes avec la fonction LongueurFichier().

Tu as plusieurs possibilités alors et celle-ci est dérivée directement du code actuel mais avec l'allocation dynamique :

Pour simplifier l'écriture du code, on définira un type Ligne comme un tableau de TAILLE_MAX char (ce n'est pas obligatoire, mais le code est plus clair de cette façon):

Code :

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

1
2
3
4
5
6
7
8
typedef char Ligne[TAILLE_MAX];
// Il nous faut un tableau de N Lignes :
Ligne * TabD = malloc( N*sizeof *TabD);
if(TabD != NULL) // on vérifie que l'allocation a réussie
{ 
   //ici, c'est pareil qu'avant
}
free(TabD); //On libère la mémoire quand on n'en a plus besoin.