problème d'allocation de tableau

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonsoir,

Je voulais copier le contenu de fichier "exemple.txt" dans un tableau dynamique tab de taille inconnue en avance. J'utilise le tableau pour faciliter la manipulation après.
Chaque ligne de fichier contient une chaine de caractère :
nom
prenom
age
adresse
emploi

Voici le programme:
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 #include <stdio.h> #include <stdlib.h> #include<string.h> int allocation(int N) { FILE *fp; char *t,s[100],attribut[32]; int i; t = (char *) malloc((N)*sizeof(char)); fp=fopen("exemple.txt","r"); for(i=0; i < N;i++) { fgets(s, 100, fp); sscanf(s,"%s",attribut); strcpy(t[i],attribut); printf("%s ",t[i]); } fclose(fp); return 0; } int main () { FILE *fp = NULL; char s[100]; int N=0; //N est calculer : c'est le nombre des lignes de fichier "attribut.txt" puisque chaque ligne de ce fichier contient un attribut qui est l'objet de la combinaison while (fgets(s,100,fp)!= NULL) N++; allocation(N); fclose(fp); return 0; }
J'ai remarqué que le problème déclenche juste après l'ouverture de fichier "attribut.txt" dans la fonction allocation(N).
Comment on résoudre ce problème ?

Je serais très reconnaissant pour vos aides.

Merci.

22/08/2009, 21h47
gl
Citation:
Envoyé par siempre

Code:

1 2 3 4 5 6 FILE *fp = NULL; .... while (fgets(s,100,fp)!= NULL)
Lorsque tu appelles fgets(), tu n'as ouvert aucun fichier et fp vaut donc NULL.

Bonsoir,

Le même problème. Voici le programme modifié:

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
 
#include <stdio.h>
#include <stdlib.h>
 
int allocation(int N) 
 {
	FILE *fp;
	char *t,s[100],attribut[32];
	int i;
 
	t = (char *) malloc((N)*sizeof(char));
	fp=fopen("exemple.txt","r");
	rewind(fp);
 
	for(i=0; i < N;i++)
        {
	 fgets(s, 100, fp);
         sscanf(s,"%s",attribut);	
	 strcpy(t[i],attribut);
	 printf("%s ",t[i]);
	}
 
      fclose(fp);
       return 0;
 }
 
int main ()
{
FILE *fp = NULL;
char s[100];
int N=0;
fp=fopen("exemple.txt","r");
 
while (fgets(s,100,fp)!= NULL)
N++;
fclose(fp);
allocation(N);
 
return 0;
}

Merci.

Citation:
Envoyé par siempre
Bonsoir,

Le même problème. Voici le programme modifié:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #include <stdlib.h> int allocation(int N) { FILE *fp; char *t,s[100],attribut[32]; int i; t = (char *) malloc((N)*sizeof(char)); ... strcpy(t[i],attribut); printf("%s ",t[i]); ...
Le type de t est char*, donc le type de t[i] est char, ce qui n'est pas correct.

Au passage, je m'étonne que ce code puisse compiler :

Citation:

||=== test_DVP, Release ===|
E:\projet\test_DVP\main.c||In function `allocation':|
E:\projet\test_DVP\main.c|18|warning: implicit declaration of function `strcpy'|
E:\projet\test_DVP\main.c|18|error: passing arg 1 of `strcpy' makes pointer from integer without a cast|
E:\projet\test_DVP\main.c|19|warning: format argument is not a pointer (arg 2)|
||=== Build finished: 1 errors, 2 warnings ===|

Sans compter que les erreurs ne sont pas gérées par ce programme (test de malloc() et fopen(), vérification des tailles, vérification de la complétude des lignes lues, etc.)

Bonjour,

Citation:

Le type de t est char*, donc le type de t[i] est char, ce qui n'est pas correct.

t est un tableau de chaine de caractère. on ne sait pas en avance ta taille de tableau.

Je voulais copier le contenu du fichier dans un tableau.
Voici mon essai:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int allocation(int N)  
 {
	FILE *fp;
	char *t,s[100],attribut[32];
	int i,j;
 
	t = (char *) malloc(N*sizeof(char)); 
	if(t== NULL)
{
	printf("probleme d'allocation\n");
	exit(0);
} 
	fp=fopen("exemple.txt","r");
 
if (fp == NULL)
{
	printf("impossible d'ouvrier le fichier\n");
	exit(0);
}
	rewind(fp);
//copier le contenu du fichier dans le tableau
	for(i=0; i < N;i++)
    {
	    fgets(s, 100, fp);
        sscanf(s,"%s",attribut);	
	    strcpy(t[i],attribut);
 
	}
 
     //affichage le contenu de tableau
	  for(j=0;j<N;j++)
		  printf("j=%d %s\n",j,t[j]);
 
	   fclose(fp);
       return 0;
 }
 
int main(void)
{
 FILE *fp = NULL;
 char s[100];
 int N=0;
 fp=fopen("exemple.txt","r");
 if (fp == NULL)
 {
	printf("impossible d'ouvrier le fichier\n");
	exit(0);
 }
while (fgets(s,100,fp)!= NULL)
N++;
fclose(fp);
allocation(N);
  return 0;
}

Mais, l'exécution ne passe pas bien !!

Merci

23/08/2009, 11h55
gl

Citation:

Envoyé par siempre

t est un tableau de chaine de caractère. on ne sait pas en avance ta taille de tableau.

Non, "char *t" déclare un pointeur sur char. Une fois l'allocation faite, t pointe sur un tableau de caractère (qui pourra représenté une chaîne de caractère), pas sur un tableau de chaîne de caractère.

D'ailleurs comme indiqué dans mon message précédent, le compilateur remonte une erreur (je ne vois d'ailleurs pas comment tu pourrais bien exécuter ce code qui ne compile pas) sur :

Code:

strcpy(t[i],attribut);

Non.l'affichage nous donne toute la chaine et n'est pas une lettre de chaine

Code:

1
2
3
4
5
6
7
8
int main()
{
char *t[5]={"lundi","mardi","mars","avril","dimanche"};
int i;
for(i=0;i<5;i++)
printf("%s\n",t[i]);
  return 0;
}

Le tableau est déclaré ici statiquement.
mon problème comment je vais allouer le tableau t où on va copier le contenu du fichier.

Voici mon essai:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int allocation(int N)  
 {
        FILE *fp;
        char *t,s[100],attribut[32];
        int i,j;
 
        t = (char *) malloc(N*sizeof(char)); 
        if(t== NULL)
{
        printf("probleme d'allocation\n");
        exit(0);
} 
        fp=fopen("exemple.txt","r");
 
if (fp == NULL)
{
        printf("impossible d'ouvrier le fichier\n");
        exit(0);
}
        rewind(fp);
//copier le contenu du fichier dans le tableau
        for(i=0; i < N;i++)
    {
            fgets(s, 100, fp);
        sscanf(s,"%s",attribut);        
            //strcpy(t[i],attribut);
                strcpy(t+i,attribut);
printf("%s\n",t+i);
        }
 
     //affichage le contenu de tableau
          for(j=0;j<N;j++)
                   printf("j=%d %s\n",j,t+j);
           fclose(fp);
       return 0;
 }
 
int main(void)
{
 FILE *fp = NULL;
 char s[100];
 int N=0;
 fp=fopen("exemple.txt","r");
 if (fp == NULL)
 {
        printf("impossible d'ouvrier le fichier\n");
        exit(0);
 }
while (fgets(s,100,fp)!= NULL)
N++;
fclose(fp);
allocation(N);
  return 0;
}

Je vois que la partie suivante:

Code:

1
2
3
4
5
6
7
8
    for(i=0; i < N;i++)
    {
            fgets(s, 100, fp);
        sscanf(s,"%s",attribut);        
            //strcpy(t[i],attribut);
                strcpy(t+i,attribut);
printf("%s\n",t+i);
        }

nous donne :
lundi
mardi
mars
avril
dimanche

Donc chaque case du tableau t contient une chaine du caractère.

J'ai remarqué que l'allocation se passe bien et l'ouverture du fichier se passe bien pas des messages d'erreur.
Mais la partie suivante du programme ne s'exécute pas :

Code:

1
2
3
4
 
//affichage le contenu de tableau
	  for(j=0;j<N;j++)
	           printf("j=%d %s\n",j,t+j);

Citation:
Envoyé par siempre
Non.l'affichage nous donne toute la chaine et n'est pas une lettre de chaine
Code:

1 2 3 4 5 6 7 8 int main() { char *t[5]={"lundi","mardi","mars","avril","dimanche"}; int i; for(i=0;i<5;i++) printf("%s\n",t[i]); return 0; }
Le tableau est déclaré ici statiquement.
Ici il s'agit bien d'un tableau de chaîne de caractère.

"char *t[5]" n'est pas la même chose que "char* t".

Citation:

Envoyé par siempre

mon problème comment je vais allouer le tableau t où on va copier le contenu du fichier.

Si tu veux stocker les différentes chaînes de caractères, une solution consiste à créer un pointeur de pointeur sur char (char **t), d'allouer ensuite la place nécessaire pour stocker l'adresse des chaînes de caractères puis, pour chaque ligne lue, d'allouer la taille nécessaire pour contenir la chaîne et de copier cette chaîne [1].
Ce qui en partant de ton code donnerait quelque chose du style (attention, code non testé et sans gestion d'erreur) :
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 int allocation(int N) { FILE *fp; char **t,s[100],attribut[32]; int i,j; t = malloc(N * sizeof(*t)); if(t== NULL) { printf("probleme d'allocation\n"); exit(0); } fp=fopen("exemple.txt","r"); if (fp == NULL) { printf("impossible d'ouvrier le fichier\n"); exit(0); } rewind(fp); //copier le contenu du fichier dans le tableau for(i=0; i < N;i++) { fgets(s, 100, fp); sscanf(s,"%s",attribut); t[i] = malloc(strlen(attribut)+1); strcpy(t[i],attribut); printf("%s\n",t[i]); } //affichage le contenu de tableau for(j=0;j<N;j++) printf("j=%d %s\n",j,t[j]); fclose(fp); return 0; }
[1] ces opérations pouvant être remplacé par l'utilisation de strdup() si cette fonction est disponible dans ton environnement.

23/08/2009, 14h02
siempre

Bonjour,

Citation:

[1] ces opérations pouvant être remplacé par l'utilisation de strdup() si cette fonction est disponible dans ton environnement.

Oui. Cette fonction strdup() existe dans mon environnement Visual studio sous windows.
Comment cette fonction sera incluse dans la solution ?

Merci.
23/08/2009, 16h53
Sve@r
Citation:

Envoyé par siempre

Oui. Cette fonction strdup() existe dans mon environnement... Comment cette fonction sera incluse dans la solution ?

Remplacer
Code:

1 2 t[i] = malloc(strlen(attribut)+1); strcpy(t[i],attribut);
Par

Code:

t[i] = strdup(attribut);

Maintenant, d'un point de vue plus général, ton code est assez "sale". Tu sors simplement avec exit en cas de problème initial (malheureusement si le fichier ne s'ouvre pas, tu as quand même un malloc qui n'est pas libéré et sous Windows, il n'y a pas de libération automatique de la mémoire en cas d'arrêt du programme) et tu ne gères pas le cas où un malloc intermédiaire viendrait à rater.
Théoriquement, il faudrait que, s'il y a un problème intermédiaire, tout ce qui a été alloué et/ou ouvert auparavant soit libéré et/ou refermé avant de quitter la fonction avec un code d'erreur. Et c'est le parent qui, recevant ce code d'erreur, prendra une décision (qui pourra être lui-aussi de remonter à son propre parent un code d'erreur).

Voici j'ai modifié un peu le code afin d'obtenir un code performant et complète dans tous les cas:

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
 
int allocation(int N)
{
   FILE *fp;
   char **t,s[100],attribut[32];
   int i,j;
 
   t = malloc(N * sizeof(*t));
   if(t== NULL)
   {
      printf("probleme d'allocation\n");
      exit(0);
   }
 
   fp=fopen("exemple.txt","r");
   if (fp == NULL)
   {
      printf("impossible d'ouvrier le fichier\n");
      exit(0);
   }
 
   rewind(fp);
   //copier le contenu du fichier dans le tableau
   for(i=0; i < N;i++)
   {
      fgets(s, 100, fp);
      sscanf(s,"%s",attribut);
      t[i] = strdup(attribut);
      printf("%s\n",t[i]);
   }
 
   //affichage le contenu de tableau
   for(j=0;j<N;j++)
      printf("j=%d %s\n",j,t[j]);
   fclose(fp);
free(t);
   return 0;
}

Que proposez-vous ?

23/08/2009, 18h44
jeroman

Je pense que recoder la fonction sans les exit serait bien mieux. :ccool:

Par exemple, dans ton code, tu alloues de la mémoire. Le problème, c'est qu'ensuite tu ouvres le fichier et que tu fermes sauvagement le programme à coup d'exit en cas d'échec.
Il faut structurer le programme de manière à ce qu'il libère la mémoire allouée (même si l'OS s'en charge en principe), ouverture réussie du fichier ou pas, quitte à découper chacune des tâches en sous-fonctions (enfin là, y a pas lieux de faire des sous-fonction pour si peu de lignes de code, il faut mieux structurer simplement).

Citation:
Envoyé par siempre
Voici j'ai modifié un peu le code afin d'obtenir un code performant et complète dans tous les cas:
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 int allocation(int N) { FILE *fp; char **t,s[100],attribut[32]; int i,j; t = malloc(N * sizeof(*t)); if(t== NULL) { printf("probleme d'allocation\n"); exit(0); } fp=fopen("exemple.txt","r"); if (fp == NULL) { printf("impossible d'ouvrier le fichier\n"); exit(0); } rewind(fp); //copier le contenu du fichier dans le tableau for(i=0; i < N;i++) { fgets(s, 100, fp); sscanf(s,"%s",attribut); t[i] = strdup(attribut); printf("%s\n",t[i]); } //affichage le contenu de tableau for(j=0;j<N;j++) printf("j=%d %s\n",j,t[j]); fclose(fp); free(t); return 0; }
Que proposez-vous ?
Que proposons-nous pour quoi ??? Dire ce qui ne va pas ?
1) tu sors toujours salement par exit au moindre problème sans rien nettoyer
2) ton rewind() est inutile et tu pourrais fermer ton fichier juste après l'avoir traité et non en fin de fonction
3) tu gères pas le problème d'une allocation ratée dans la boucle
4) tu libères ton tableau t sans libérer les éléments t[x] qui eux-aussi ont été alloués par strdup.

Mis à part ces remarques, ton mécanisme de remplissage semble fonctionnel.

23/08/2009, 23h17
gl

Citation:

Envoyé par siempre

Que proposez-vous ?

De rajouter les vérifications sur les tailles de chaîne (notamment lors de l'appel à sscanf()) et sur la complétude des lignes lues lors de l'appel à fgets() ( au passage pourquoi utiliser 100 en dur, sizeof(s)permet d'éviter des problèmes lors d'évolution futures).

Bonsoir,

Voici le code après modification:

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
int allocation(int N)
{
   FILE *fp;
   char **t,s[100],attribut[32];
   int i,j;
 
   t = malloc(N * sizeof(*t));
   if(t== NULL)
         printf("probleme d'allocation\n");
 
 
   fp=fopen("exemple.txt","r");
   if (fp == NULL)
         printf("impossible d'ouvrier le fichier\n");
 
    //copier le contenu du fichier dans le tableau
   for(i=0; i < N;i++)
   {
      fgets(s, 100, fp);
      sscanf(s,"%s",attribut);
      t[i] = strdup(attribut);
      printf("%s\n",t[i]);
   }
 fclose(fp);
   //affichage le contenu de tableau
   for(j=0;j<N;j++)
      printf("j=%d %s\n",j,t[j]);
 
    free(t);
   return 0;
}

S'il y a des choses qui manquent.
Pouvez-vous les ajouter car je n'arrive pas améliorer de ma part ?

Merci.

24/08/2009, 00h16
jeroman

Si "malloc" renvoie NULL, ton programme va crasher.
24/08/2009, 08h06
siempre

Bonjour,

Donc, comment éviter le problème d'allocation ?

Ce problème est coté espace mémoire et non pas au niveau programme.
24/08/2009, 08h46
siempre

Citation:

Que proposons-nous pour quoi ??? Dire ce qui ne va pas ?
1) tu sors toujours salement par exit au moindre problème sans rien nettoyer
2) ton rewind() est inutile et tu pourrais fermer ton fichier juste après l'avoir traité et non en fin de fonction
3) tu gères pas le problème d'une allocation ratée dans la boucle
4) tu libères ton tableau t sans libérer les éléments t[x] qui eux-aussi ont été alloués par strdup.

Comment je code ces 4 points ?

Citation:

De rajouter les vérifications sur les tailles de chaîne (notamment lors de l'appel à sscanf()) et sur la complétude des lignes lues lors de l'appel à fgets() ( au passage pourquoi utiliser 100 en dur, sizeof(s)permet d'éviter des problèmes lors d'évolution futures).

comment je code ceci ?

Merci.

Citation:

Envoyé par siempre

Comment je code ces 4 points ?

Wow, tu ne fais vraiment pas d'effort !!!

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
43
44
45
46
47
48
49
50
51
int allocation(int N, char *fichier)
{
   FILE *fp;
   char **t,s[100],attribut[32];
   int i;
 
   t = malloc(N * sizeof(*t));
   if(t== NULL)
   {
         fprintf(stderr, "probleme d'allocation\n");
         return -1;
   }
 
 
   fp=fopen(fichier,"r");
   if (fp == NULL)
   {
         fprintf(stderr, "impossible d'ouvrier le fichier %s\n", fichier);
         free(t);
         return -2;
   }
 
    // Initialiser le tableau (pour l'instant ça ne sert à rien mais plus tard, ça pourrait être utile)
   for(i=0; i < N;i++) t[i]=NULL;
 
   //copier le contenu du fichier dans le tableau
   for(i=0; i < N;i++)
   {
      fgets(s, 100, fp);
      sscanf(s,"%s",attribut);
      if ((t[i] = strdup(attribut)) == NULL)
      {
          fprintf(stderr, "erreur alloc t[%d]\n", i);
          for (int j=0; j < i; j++) free(t[j]);
          free(t);
          fclose(fp);
          return -3;
      }
 
      printf("%s\n",t[i]);
   }
    fclose(fp);
 
   //affichage le contenu de tableau
   for(i=0;i<N;i++)
      printf("t[%d]=%s\n",i,t[i]);
 
   for (i=0; i < N; i++) free(t[i]);
   free(t);
   return 0;
}

Citation:

Envoyé par siempre

S'il y a des choses qui manquent.

Ouaip, j'ai tapé ce code vite fait pour te montrer le principe mais un code plus raffiné ferait du realloc pour agrandir le tableau comme ça on évite d'avoir à compter le nombre de lignes

24/08/2009, 23h30
siempre

Bonsoir,

Quelle est la différence entre free(t) et free(t[i]) ?
Si on fait free(t) ceci implique free(t[i]) ?

Voir 40 message(s) de cette discussion en une page