problème d'allocation de tableau

Version imprimable

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]) ?
24/08/2009, 23h36
Sve@r

Citation:

Envoyé par siempre

Bonsoir,

Quelle est la différence entre free(t) et free(t[i]) ?

t est un pointeur de type char ** alloué à un certain moment
t[i] est un pointeur de type char alloué à un autre moment
Les 2 pointeurs possèdent tous deux une zone mémoire distincte. Il n'y a donc aucune différence entre free(t) et free(t[i]). Chaque fonction libère la zone mémoire concernée.

Citation:

Envoyé par siempre

Si on fait free(t) ceci implique free(t[i]) ?

Eh non (comment le compilo sait que dans la zone "t" tu y as stocké d'autres pointeurs eux-aussi alloués ???)
Pire, la zone allouée pour t contient des pointeurs pointant vers diverses zones allouées pour les différents t[x]. En libérant t sans libérer t[x], on perd ces pointeurs mais les zones ne sont pas libérées => mémoire perdue (et sous Windows, il faut redémarrer l'ordi pour la retrouver !!!)

J'ai ajouté des améliorations:

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
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
#include <stdio.h>
#include <string.h>
 
#define NOMBRE_CARACTERES_PAR_LIGNE_MAX	100
 
typedef enum
{
	CODE_ERREUR_SUCCES = 0,
	CODE_ERREUR_ECHEC = 1,
}CodeErreur;
 
int allocation(int N)
{
	CodeErreur codeErreur = CODE_ERREUR_ECHEC;
 
	char** t = (char**) malloc(N * sizeof (*t));
 
	if (t)
	{
		FILE* fp = fopen("exemple.txt", "r");
 
		if (fp)
		{
			char s[NOMBRE_CARACTERES_PAR_LIGNE_MAX];
			char attribut[NOMBRE_CARACTERES_PAR_LIGNE_MAX];
 
			int i;
			int j;
 
			//copier le contenu du fichier dans le tableau
			for (i = 0; i < N; i ++)
			{
				if (fgets(s, NOMBRE_CARACTERES_PAR_LIGNE_MAX, fp))
				{
					if (sscanf(s, "%s", attribut) > 0)
					{
						t[i] = strdup(attribut);
 
						if (t[i])
						{
							printf("%s\n", t[i]);	
						}
						else
						{
							printf("Pas assez de memoire disponible pour dupliquer la chaine.\n");
 
							break;
						}
					}
					else
					{
						printf("Echec de sscanf().\n");
 
						break;
					}
				}
				else
				{
					printf("Echec de fgets().\n");
 
					break;
				}
			}
 
			if (i == N)
			{
				//afficher le contenu de tableau
				for (j = 0; j < N; j ++)
				{
					printf("j = %d, s = %s\n", j, t[j]);
				} 
 
				codeErreur = CODE_ERREUR_SUCCES;
			}
 
			fclose(fp);
		}
		else
		{
			printf("impossible d'ouvrir le fichier\n");
		}
 
		free(t);
	}
	else
	{
		printf("probleme d'allocation\n");
	}
 
	return codeErreur;
}
 
 
int main(int argc, char* argv[])
{
	switch (allocation(5))
	{
		case CODE_ERREUR_SUCCES:
			printf("Succes de allocation()\n");
 
			break;
 
		case CODE_ERREUR_ECHEC:
			printf("Echec de allocation()\n");
 
			break;
 
		default:
			printf("allocation() a retourne un code d'erreur inconnu.\n");
	}
 
	return 0;
}

Citation:
Envoyé par cameleon65
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 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 #include <stdio.h> #include <string.h> #define NOMBRE_CARACTERES_PAR_LIGNE_MAX 100 typedef enum { CODE_ERREUR_SUCCES = 0, CODE_ERREUR_ECHEC = 1, }CodeErreur; int allocation(int N) { CodeErreur codeErreur = CODE_ERREUR_ECHEC; char** t = (char**) malloc(N * sizeof (*t)); if (t) { FILE* fp = fopen("exemple.txt", "r"); if (fp) { char s[NOMBRE_CARACTERES_PAR_LIGNE_MAX]; char attribut[NOMBRE_CARACTERES_PAR_LIGNE_MAX]; int i; int j; //copier le contenu du fichier dans le tableau for (i = 0; i < N; i ++) { if (fgets(s, NOMBRE_CARACTERES_PAR_LIGNE_MAX, fp)) { if (sscanf(s, "%s", attribut) > 0) { t[i] = strdup(attribut); if (t[i]) { printf("%s\n", t[i]); } else { printf("Pas assez de memoire disponible pour dupliquer la chaine.\n"); break; } } else { printf("Echec de sscanf().\n"); break; } } else { printf("Echec de fgets().\n"); break; } } if (i == N) { //afficher le contenu de tableau for (j = 0; j < N; j ++) { printf("j = %d, s = %s\n", j, t[j]); } codeErreur = CODE_ERREUR_SUCCES; } fclose(fp); } else { printf("impossible d'ouvrir le fichier\n"); } free(t); } else { printf("probleme d'allocation\n"); } return codeErreur; }
J'ai ajouté des améliorations:
Ouaip bon. Déjà t'as oublié de libérer les t[x]. De plus, les types créés sont habituellement nommés "t_xxx" afin de ne pas les confondre avec des variables et le flux stderr n'a pas été créé que pour les pingouins.
De plus ta gestion des erreurs est efficace mais si t'as 50 cas à évaluer, une fois que tout est correct tu vas te retrouver à programmer complètement à droite de ton écran.
Je préfère la technique
- je prends une ressource
- si la ressource n'est pas disponible j'arrête tout en nettoyant ce qui a déjà été fait
Certes il y a des répétions d'instruction mais quand tu arrives au travail réel, tu as encore toute la place pour programmer ton algo
Et on peut éviter ces répétions de code en utilisant un "goto error" judicieusement placé où le bloc error contiendra les instructions de nettoyage (voir discussion sur le goto => http://www.developpez.net/forums/d75.../c/pensez-goto)

J'avais pas oser mettre des goto à la place des break à cause qu'il y a des gens qui n'aime pas.

Je préfère mettre en majuscule la première lettre d'un type, un peu comme on fait en java.

S'il y a pleins d'imbrications et on est rendu à programmer le vrai traitement à droite, on peut faire ce que tu as dit ou mettre le traitement dans une fonction [inline], mais là aussi il y a d'autres types d'inconvénients.

J'ai fait des modifications:

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
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define NOMBRE_CARACTERES_PAR_LIGNE_MAX	100
 
typedef enum
{
	CODE_ERREUR_SUCCES = 0,
	CODE_ERREUR_ECHEC = 1,
}CodeErreur;
 
int allocation(int N)
{
	CodeErreur codeErreur = CODE_ERREUR_ECHEC;
 
	char** t = (char**) malloc(N * sizeof (*t));
 
	if (t)
	{
		FILE* fp = fopen("exemple.txt", "r");
 
		if (fp)
		{
			char s[NOMBRE_CARACTERES_PAR_LIGNE_MAX];
			char attribut[NOMBRE_CARACTERES_PAR_LIGNE_MAX];
 
			int i;
			int j;
 
			//copier le contenu du fichier dans le tableau
			for (i = 0; i < N; i ++)
			{
				if (fgets(s, NOMBRE_CARACTERES_PAR_LIGNE_MAX, fp))
				{
					if (sscanf(s, "%s", attribut) > 0)
					{
						t[i] = strdup(attribut);
 
						if (t[i])
						{
							printf("%s\n", t[i]);
						}
						else
						{
							fprintf(stderr, "Pas assez de memoire disponible pour dupliquer la chaine.\n");
 
							goto LIBERATION_MEMOIRE;
						}
					}
					else
					{
						fprintf(stderr, "Echec de sscanf().\n");
 
						goto LIBERATION_MEMOIRE;
					}
				}
				else
				{
					fprintf(stderr, "Echec de fgets().\n");
 
					goto LIBERATION_MEMOIRE;
				}
			}
 
			//afficher le contenu de tableau
			for (j = 0; j < N; j ++)
			{
				printf("j = %d, s = %s\n", j, t[j]);
			} 
 
			codeErreur = CODE_ERREUR_SUCCES;
 
			LIBERATION_MEMOIRE:
				for (; i >= 0; i --)
				{
					free(t[i]);
				}
 
				fclose(fp);
		}
		else
		{
			fprintf(stderr, "impossible d'ouvrir le fichier\n");
		}
 
		free(t);
	}
	else
	{
		fprintf(stderr, "probleme d'allocation\n");
	}
 
	return codeErreur;
}
 
int main(int argc, char* argv[])
{
	switch (allocation(5))
	{
		case CODE_ERREUR_SUCCES:
			printf("Succes de allocation()\n");
 
			break;
 
		case CODE_ERREUR_ECHEC:
			printf("Echec de allocation()\n");
 
			break;
 
		default:
			printf("allocation() a retourne un code d'erreur inconnu.\n");
	}
 
	return 0;
}

Fuseau horaire GMT +2. Il est actuellement 04h55.