en simplifiant mon pg :
 
if (j<10)
{
j++;
printf("%d\n",j);
}
 
il se passe un truc trop chelou :
qd le printf est present le prog tourne ...
mais qd je l'enleve ou le met en commentaire ...
g un segmentation fault ...
 
if (regegerge)
{
j++;
}
=>>> erreur  
 
alors la je capte plus rien !!!!!!!!!!!!
 
bien sur c n'etait pas ce code qui merdais mais un prog bc plus important mais le bug revient a ca ...
si quelq'un vois ou a deja eu pareil
 
il faut signaler (je sais pas si ca a une importance mais ce teste se situe deja a l'interieur d'un dizzaine de test imbriques ...
 
je compille sous la mandrake 8.1 avec gcc 3.0.1

a te dire comme ca je vois pas, attaque ca au debuggeur ....
 
edit : t sur que ton J sert pas ensuite comme index dans un tableau, et qu'il serait > a la taille dudit tableau ? (ca explique pas trop pkoi ca plante pas dans un cas et dans l'autre, mais bon...)

[edtdd]--Message édité par chrisbk--[/edtdd]

 
le dernier test imbrique est proprement dit est :
char *lelien;
....  
 
while ((!eof(entree)) && (sortie == 0)
{
  if ((i == ' ' || (i == '>')
  {
    lelien[j] = '\n';
    printf("%s\n",lelien);
    j = 0;
    sortie = 1;
  }
  fread(&i, sizeof(char), 1, entree);
}
 
aparement ca correspond peut etre au pb que tu m'a dis ...
je sai pas corriger ...

 
je sais pas me servir du debugger

lelien est bien alloué la bonne taille ?
 
 
(sinon, apprends a te servir d'un debuggeur, c vraiment la bequille indispensable quand ton prog plante. enfin je sais pas trop sous linux ce qu'il y a comme debugger valable...)

hum attends je crois que je vois
 
remplace :
 
lelien[j] = '\n';  
printf("%s\n",lelien);  
 
 
par
 
lelien[j] = '\n';  
lelien[j+1] = 0;  
printf("%s\n",lelien);

 
en effet ca marche ...
mais g pas capte prkoi ...
lelien[j] = '\0';  
le \0 correspond prtt a une fin de string alors prkoi mettre le 0 apres ... pour moa c le \0 qui fait tt !
 
en tt cas merci

sauf que la tu a pas fait \0 mais \n

encore un petit pb ...
juste un Warning qui apparait avec le -Wall
'lelien' might be used unitialized in this function
je traduit ca par  
"'lelien' devrait etre utiliser pas intitialise dans cette fonction"
char *void
c ce qui est fait non ?!

c t une faute de frappe j'avais bien tape \0

Non il te dit que lelion sera peut etre utilisé sans etre initialisé
 
t'alloc bien la mémoire, pour lelien ?

nop je l'utilise tel quel !
 
char *lelien  
 
et apres ...
lelien[j] = 'X';

C pour ça que ça plante....
Il faut allouer de la mem por lelien
genre
lelien = (char *)malloc(100 * sizeof(char));
avec 100 la taille de ton tableau.....

je croyais qu'avec char *lelien
il allouais la memeoire tt seul comme un gd !
sinon autant utiliser  
char lelien[100]
j'utilisais le dynamique exprtes pour pas etre limite et avec  
lelien = (char *)malloc(100 * sizeof(char));
je suis limite a 100 char !

Non, quand tu ecris 'char *lelien', ca te cree un pointeur lelien. Mais il pointe sur rien.
Quand tu mets 'char lelien[100]', ca alloue effectivement une zone memoire de 100 caracteres, avec lelien qui pointe dessus.
 
De toute facon, tu peux pas avoir une taille allouee sans lui dire a un moment combien il te faut.

Non avec allocation dynamique T pas limité (C à ça que ça sert)
Regarde l'aide de malloc et de realloc
(si C++ il y a new....)
ID : alloue un buffer (genre 1024) si dépassement realloue le double (2048) etc..... (Je suis ptet pas trés clair....)
Si tu comprends pas demande j'expliquerai +....

en effet pas tout compris

ce que SDF veut te dire c'est ca :
 
1) allouer dynamiquement un tableau de 1024 case
2) ecrire dans ce tableau
3) si a un moment tu ecris a la case 1024, alors
   - allouer nouveau tableau de 2048 case
   - recopier les 1024 premieres cases du tableau dans le nouveau
   - effacer le premier tableau
   - continuer a travailler avec le deuxieme ( de 2048)
 
 
exemple :
 
int courant = 0;
int max  = 1024;
char * tab = malloc(1024);
char * tab2;
while(....)
{
  ........
  tab[courant] = trucBidule;
  courant++;
 
  if (courant == max)
  {
    max+=1024;
    tab2 = malloc(max);
    memcpy(tab2,tab,courant);  
    free(tab);
    tab = tab2;
  }
  ........
}
 
See ?

otb82 a écrit a écrit :   en effet pas tout compris

oki
Ex :
 
char *lelien;
int taille;
....  
 
taille = 1024
lelien = (char *)malloc(taille * sizeof(char));
 
while ((!eof(entree)) && (sortie == 0)
{
 if ((i == ' ' || (i == '>')
 {
   if (j >= taille) {
     lelien = (char *)realloc(taille * sizeof(char));
     taille = taille + 1024;
   }
   lelien[j] = '\0';
   printf("%s\n",lelien);
   j = 0;
   sortie = 1;
 }
 fread(&i, sizeof(char), 1, entree);
}
 
Bon G fait ça de mémoire  y a ptet des bugs.... (en + il est tôt   )
T'as compris l'idée ?

   
+ rapide que moi....
Là si il à pas compris.....  

je post plus vite que mon ombre
 
ton realloc sera peut etre plus explicite (mais j'utilise jamais realloc..)

chrisbk a écrit a écrit : je post plus vite que mon ombre   ton realloc sera peut etre plus explicite (mais j'utilise jamais realloc..)

Ben en fait ça fait longtemps que j'ai pas fait de l'allocation dynamique....
Tien G oublié de lui dire qu'un jour faut qu'il libére la mem...