probleme de tableau dynamique

Version imprimable

La fonction extraire_donnee() permet de lire caractere par caractere une chaine de caractere passee en parametre. Le but etant d'extraire des champs separés par des ';'dans la chaine passe en parametre et de les inserer dans un tableau dynamique de chaines de caracteres. Je ne peux pas utiliser la fonction sscanf car le nombre de champs séparé par des ';' dans la chaine passé en paramètre est variable.
Mon probleme est le suivant : apres le deuxieme champs trouvé et extrait j'ai un mechant plantage (memory fault coredump sous windows = "voulez-vous envoyer l'erreur a MicroSoft).
Quelqu'un peut il m'aider a resoudre ce core car j'ai beau chercher je ne vois pas ou ce situe l'erreur. Merci.
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 #include <stdio.h> #include <stdlib.h> #include <string.h> void extraire_donnees(char *ptr_buffer_lecture) { int ligne = 0; char **ptr; int separateur = 0; int indice; int longueur = 0; ptr = (char**)malloc(sizeof(char*)); ptr[ligne]=(char*)malloc(sizeof(char)); for (indice = 0; ptr_buffer_lecture[indice] != '\0'; indice ++ ) { if ((ptr[ligne]=realloc(ptr[ligne],sizeof(char) * longueur + 1)) == NULL) printf("probleme d'allocation memoire\n"); if(ptr_buffer_lecture[indice] != ';') { ptr[ligne][longueur] = ptr_buffer_lecture[indice]; //printf("ptr[%d][%d]= %c\n",ligne,longueur,ptr[ligne][longueur]); longueur++; } else{ longueur++; separateur++; if (longueur == 1) printf("Probleme de longueur de la chaine\n"); ptr[ligne][longueur - 1 ]='\0'; longueur = 0; printf("*ptr[%d]= %s\n",ligne,ptr[ligne]); if((ptr=realloc(ptr,sizeof(char*) * (separateur + 1))) == NULL ) printf("probleme d'allocation memoire 2 \n"); ligne++; ptr++; } } for (ligne = 0; ligne <separateur;ligne++) printf("*ptr[%d]= %s\n",ligne,ptr[ligne]); } int main(void) { char *test ="CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;\0"; printf("test = %s\n",test); extraire_donnees(test); return EXIT_SUCCESS; }

Le problème c'est que lors du realloc, tu lis l'adresse ptr[2] alors qu'il n'a pas encore été alloué d'espace mémoire pour cette adresse
Pour que realloc se comprte comme malloc en cas d'espace mémoire pas encore élloué il faut envoyer NULL comme premier paramètre

:arrow: SOLUTION:
Initialise ptr[ligne] à NULL juste après l'augmentation de ligne.
C'est à dire, voici le code qui marche:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
void extraire_donnees(char *ptr_buffer_lecture)
{
 int ligne = 0;
 char **ptr;
 int separateur = 0;
 int indice;
 int longueur = 0;
 
   ptr = (char**)malloc(sizeof(char*));
   ptr[ligne]=(char*)malloc(sizeof(char));
 
   for (indice = 0; ptr_buffer_lecture[indice] != '\0'; indice ++ )
   {
 
 
      if ((ptr[ligne]=realloc(ptr[ligne],sizeof(char) * longueur + 1)) == NULL)
         printf("probleme d'allocation memoire\n");
 
      if(ptr_buffer_lecture[indice] != ';')
         {
 
            ptr[ligne][longueur] = ptr_buffer_lecture[indice];
            //printf("ptr[%d][%d]= %c\n",ligne,longueur,ptr[ligne][longueur]);
            longueur++;
         }
      else{
            longueur++;
            separateur++;
            if (longueur == 1)
               printf("Probleme de longueur de la chaine\n");
            ptr[ligne][longueur - 1 ]='\0';
            longueur = 0;
            printf("*ptr[%d]= %s\n",ligne,ptr[ligne]);
 
            if((ptr=realloc(ptr,sizeof(char*) * (separateur + 1))) == NULL )
               printf("probleme d'allocation memoire 2 \n");
            ligne++;
            ptr++;
            ptr[ligne] = NULL;   // <--- *modif*
         }
 
 
   }
 
   for (ligne = 0; ligne <separateur;ligne++)
      printf("*ptr[%d]= %s\n",ligne,ptr[ligne]);
 
}
 
 
int main(void)
{
   char *test ="CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;\0";
   printf("test = %s\n",test);
 
                 extraire_donnees(test);
 
   return EXIT_SUCCESS;
}

A+ ;-)

25/06/2004, 13h30
El Krotal
Merci pour la rapidite de la reponse
Je ne comprends pas pourquoi tu dis :

Citation:

Le problème c'est que lors du realloc, tu lis l'adresse ptr[2]

Neanmoins, j'ai bien rajouter la ligne que tu m'as indiqué
Code:

1 2 ptr[ligne] = NULL; // <--- *modif*
et j'ai une chaine de plus qui est extraite puis un "probleme d'allocation memoire 2"

Comment peux t on remedier a ce probleme ?

Bon j'ai regardé et essayé ton code... Y'a plusieurs trucs qui vont pas.
Déjà au niveau du realloc ( et c'est pour ça qu'il plante ) il faut caster ta mémoire de sortie. Je m'explique:
Code:

1 2 3 4 5 6 7 // Realloc ne sait pas le type de mémoire en sortie donc void *. // Or tu as du char* ici. if ((ptr[ligne]=realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL) // Solution : if ((ptr[ligne]=(char*)realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL)
De même un peu plus bas tu fais un réalloc sur du char** et lui pense que c'est du void*.

J'ai fait les modifs, et chez moi ça passe.

Ensuite tu as un sérieux problème au niveau de la réallocation, cette fonction ne rajoute pas de la mémoire, elle réattribut un total :
Code:

1 2 3 4 5 6 // Alloue 5 octet pour ptr : char *ptr = malloc(sizeof(char)*5); // Si tu fais : ptr = (char*)realloc(ptr,sizeof(char*),20); // alors ptr aura une taille mémoire de 20 octets et non pas 25.
Donc ça veut dire que quand tu trouves un ";" tu détruit toute ta zone mémoire qui contenait ta première chaine.

De plus en faisant ça tu alloues une taille de 1 octet (au premier ";") à ton ptr, ce qui fait que quand tu arrive au realloc suivant :
Code:

1 2 if ((ptr[ligne]=(char*)realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL)
ligne vaut 1 et donc tu sors de ton espace mémoire = segfault...

Donc fais bien gaffe avec le realloc.
Bon j'espère que je suis assez clair, j'ai du mal à m'expliquer... La notion de la mémoire dynamique en C est assez complexe.
Si tu veux eviter ce problème de malloc et realloc, tu peux faire un tableau statique pour commencer...
Dans ton cas ça ferais :
Code:

1 2 3 4 // Déclare un tableau de 200 chaines pouvants contenir // 1024 charactères chacunes. char ptr[1024][200];
Voili, voilou, sinon j'vais essayer de modifier ton code pour le faire marcher en dynamique, ça pourras peut-être t'aider :wink:

Bon je balance un peu de code ( pas tester au maximum) si ca peut te donner des idées parce que c'est vrai que lorsque ca commence a allouer de la mémoire partout ca devient vite dur a lire a cette heure la

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
 
#include <stdio.h>
<...>
//s : chaine source
// separateur : separateur de chaine
// retour : nombre de chaine 
int nb_chaine( char * s , char *separateur) {
        char * ptr=NULL;
        int nb_ch = 0 ;
        ptr=s;
       while( (ptr=(char*)strstr(ptr,separateur))!=NULL ){
              nb_ch ++ ;
              ptr++;
       }
return nb_ch ;
}
//ch : chaine source
// retour : tableau de pointeur sur chaine fini par la chaine NULL
char** extraire_donnees( char * ch){
    int nb_ch = 0 ;
    int lg = 0 ;
    int pos = 0 ;
    char * ptr=NULL ;
    char *adr =NULL;
    int i=0;
     char ** recup =NULL;
    //recup nombre de chaine
    nb_ch = nb_chaine(ch,";");
    recup=(char**)malloc((nb_ch+1) * sizeof(char**));
    for(;i<nb_ch;i++) recup[i]=(char*)malloc(sizeof(char*));
    recup[nb_ch]=NULL;
 
    ptr = ch ;
    adr = ch ;
    while( (ptr=(char*)strstr(ptr,";"))!=NULL && pos<nb_ch){
           ptr++;
           lg = ptr-adr ;
          recup[pos]=(char*)realloc(recup[pos],lg);
          if(recup[pos]==NULL)return NULL ;   //prevoir la désallocation de recup de 0 a pos-1
           strncpy(recup[pos] ,adr , lg-1);
           recup[pos][lg-1]=0;
           adr = ptr ;
           pos++;
     }
   return recup ;
}
int main(int argc, char *argv[])
{
char *test ="CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;\0";
int i,j;
char ** recup ;
recup = extraire_donnees(test) ;
 
i=0;
while(recup[i])
   printf("%s\n" , recup[i++]);
 
  fflush(stdout);
  printf("FINI PRESS ENTER");
  getchar();
 //faire la desallocation
   return 0;
 
}

Citation:

Envoyé par Polux63

Bon j'ai regardé et essayé ton code... Y'a plusieurs trucs qui vont pas.
Déjà au niveau du realloc ( et c'est pour ça qu'il plante ) il faut caster ta mémoire de sortie. Je m'explique:

Code:

1
2
3
4
5
6
7
 
// Realloc ne sait pas le type de mémoire en sortie donc void *.
// Or tu as du char* ici. 
if ((ptr[ligne]=realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL)
 
// Solution :
if ((ptr[ligne]=(char*)realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL)

De même un peu plus bas tu fais un réalloc sur du char** et lui pense que c'est du void*.

J'ai fait les modifs, et chez moi ça passe.

Laisse moi deviner tu fais du C avec une compilateur C++ ... En C il n'y a pas de cast à mettre devant le malloc(), calloc(), realloc() et compagnie.

Il y a beaucoup plus simple que ta méthode, si tu as des question n'hésite pas :

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
 
void extraire_donnees(const char *str)
{
	char **champs;
	char tampon[256];
	int nb_champs  = 0;
	int cur_champs = 0;
	int i		   = 0;
	int str_len	   = strlen(str);
 
	while(str[i])
	{
		if(str[i] == ';')
		{
			++nb_champs;
		}
		++i;
	}
 
	champs = malloc(nb_champs * sizeof(char*));
 
	i = 0;
	memset(tampon, '\0', 256);
	while(i < str_len && memccpy(tampon, str+i, ';', 256))
	{
		champs[cur_champs] = calloc(strlen(tampon) + 1, sizeof(char)); /* sizeof(char) optionnel car il vaut 1 */
		strncpy(champs[cur_champs], tampon, strlen(tampon)-1);
		++cur_champs;
		i += strlen(tampon);
		memset(tampon, '\0', 256);
	}
 
	if(i < str_len)
	{
		champs[cur_champs] = malloc(strlen(str+i) + 1); /* le +i est à l'intérieur du strlen(), ce n'est pas une erreur. */
		strcpy(champs[cur_champs],str+i);
		i += strlen(str+i);
	}
 
	// vérification
 
	i = 0;
 
	while(i < nb_champs)
	{
		printf("Champ %d : %s\n", i, champs[i]);
		++i;
	}
}
 
int main(void)
{
   char *test ="CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;\0";
   printf("test = %s\n",test);
 
   extraire_donnees(test);
 
   return EXIT_SUCCESS;
}

En sortie :

Code:

1
2
3
4
5
6
 
test = CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;
Champ 0 : CATEGORIE
Champ 1 : REFERENCE
Champ 2 : C012 EQ TAB12
Champ 3 : C056 GT TAB056A TAB056B

PS : Ca fait plaisir de voir un return EXIT_SUCCESS; !! ;)

Bon voilà, c'est ok, en dynamique.
Bon déjà je me corrige, ton problème ne venait pas du fait que realloc n'ajoute pas la mémoire, j'avais mal lu ton code.

Le problème était que tu faisait un realloc sur un pointeur qui n'avait jamais été alloué, il fallait donc y faire un malloc.

Je m'explique, le premier coup que tu fais ton realloc avec de ptr[ligne], ça se passe bien, parce que tu as fait un malloc avant d'entrer dans ton for( ; ; ). Mais le deuxième coup que tu y passes ligne vaut 1 or, ptr[ligne] (donc ptr[1]) n'est pas alloué, donc la malloc ne passe pas.

Ensuite un autre truc, quand tu trouves ton ";" tu incrémente ton ptr, or si tu incrémente ton ptr, et que tu fais ptr[1], y'a pas de mémoire alloué à cette endroit puisque tu as incrémenté ton ptr.

bon bref, j'ai fait 2 3 modifs, et là ça marche donc je te laisse le 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
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
 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <conio.h>
 
 
void extraire_donnees(char *ptr_buffer_lecture) 
{ 
 int ligne = 0; 
 char **ptr; 
 int separateur = 0; 
 int indice; 
 int longueur = 0; 
 
   ptr = (char**)malloc(sizeof(char*)); 
   ptr[ligne]=(char*)malloc(sizeof(char)); 
 
   for (indice = 0; ptr_buffer_lecture[indice] != '\0'; indice ++ ) 
   { 
 
	  // Reallocation de mémoire pour la lecture :
      if (ligne < 1 || longueur != 0 )
	  {
		  if ((ptr[ligne]=(char*)realloc(ptr[ligne],sizeof(char) * (longueur + 1))) == NULL) 
			  printf("probleme d'allocation memoire\n"); 
	  }
	  else
	  {
		  ptr[ligne] = (char*)malloc(sizeof(char) * (longueur + 1));
		  if (ptr[ligne] == NULL)
			  printf("probleme d'allocation memoire\n"); 
	  }
 
      if(ptr_buffer_lecture[indice] != ';') 
         { 
 
            ptr[ligne][longueur] = ptr_buffer_lecture[indice]; 
            //printf("ptr[%d][%d]= %c\n",ligne,longueur,ptr[ligne][longueur]); 
            longueur++; 
         } 
      else{ 
            longueur++; 
            separateur++; 
            if (longueur == 1) 
               printf("Probleme de longueur de la chaine\n"); 
            ptr[ligne][longueur - 1 ]='\0'; 
            longueur = 0; 
            printf("*ptr[%d]= %s\n",ligne,ptr[ligne]); 
 
            if((ptr=(char**)realloc(ptr,sizeof(char*) * (separateur + 1))) == NULL ) 
               printf("probleme d'allocation memoire 2 \n"); 
            ligne++; 
            // Si tu avances ton pointeurs, tu perds tes valeurs rentrées avant et en
			// plus tu sors de ton espaces alloué quand tu fais ptr[1]
			//ptr++; 
 
         } 
 
 
   } 
 
   for (ligne = 0; ligne <separateur;ligne++) 
      printf("ptr[%d]= %s\n",ligne,ptr[ligne]); 
 
} 
 
 
int main(void) 
{ 
   char *test ="CATEGORIE;REFERENCE;C012 EQ TAB12;C056 GT TAB056A TAB056B;\0"; 
   printf("test = %s\n",test); 
 
   extraire_donnees(test); 
 
   getch();
 
   return EXIT_SUCCESS; 
}

PS : j'ai rajouté le getch() à la fin, pour que je puisse voir les résultats du traitement, parce qu'avec VS .NET 2003 la fenêtre se barrait à chaque coups, comme c'est pas standard, je te conseilles de l'enlever :lol:

Voilà...

25/06/2004, 16h12
Polux63

Ah oui c'est vrai, j'ai tendance à oublier que ce fichus VS .NET 2003 ne prends que le C++ donc forcement y'a des trucs qui diffèrent. mais bon de toutes manières, un cast, ça mange pas de pain... :lol:
Enfin c'est encore de la chance que je sois pas obligé de garder VS 6.0 pour pouvoir faire du C sans le framework...
Bah en tous cas, là y'a pleins de solutions qui marchent au moins... LOL.
25/06/2004, 16h12
Yabo
Citation:
Envoyé par Polux63

Bon voilà, c'est ok, en dynamique.
Bon déjà je me corrige, ton problème ne venait pas du fait que realloc n'ajoute pas la mémoire, j'avais mal lu ton code.

Le problème était que tu faisait un realloc sur un pointeur qui n'avait jamais été alloué, il fallait donc y faire un malloc.

Je m'explique, le premier coup que tu fais ton realloc avec de ptr[ligne], ça se passe bien, parce que tu as fait un malloc avant d'entrer dans ton for( ; ; ). Mais le deuxième coup que tu y passes ligne vaut 1 or, ptr[ligne] (donc ptr[1]) n'est pas alloué, donc la malloc ne passe pas.

Ensuite un autre truc, quand tu trouves ton ";" tu incrémente ton ptr, or si tu incrémente ton ptr, et que tu fais ptr[1], y'a pas de mémoire alloué à cette endroit puisque tu as incrémenté ton ptr.

bon bref, j'ai fait 2 3 modifs, et là ça marche donc je te laisse le code.

Code:

1 2 <snip>
Inutilement compliqué, voir le code que j'ai donné ci-dessus.

Citation:

Envoyé par Polux63

PS : j'ai rajouté le getch() à la fin, pour que je puisse voir les résultats du traitement, parce qu'avec VS .NET 2003 la fenêtre se barrait à chaque coups, comme c'est pas standard, je te conseilles de l'enlever :lol:

Voilà...

Ce qui explique que tu aies des erreurs si tu ne caste pas sur les malloc() ... Mais sache qu'en C il n'en faut pas ;)

EDIT : Post croisé ;)
25/06/2004, 17h00
El Krotal

Merci a tous du temps que vous avez consacré a mon post.

Plusieurs solutions s'offrent a moi. J'ai testé celle de polux63 qui est dans la continuité du code que j'avais commencé a écrire et ça marche!! :D . C'est pas la solution la plus simple ni la plus pertinente mais j'ai l'impression que c'est la mienne (ma façon de penser...un peu tordu je le conçois).

Merci a Hegros et Yabo , le coup de compter la longueur de chaque champs avant d'allouer de la memoire c'etait plutot logique( :oops: j'aurais du y penser) ainsi que de s'indexer dans la chaine traitée après chaque séparateur . 8)

Encore Merci