Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2016 connectés 

  FORUM HardWare.fr
  Programmation
  C

  [c] erreur de segmentation

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[c] erreur de segmentation

n°1946725
jamsss
Posté le 02-12-2009 à 19:07:01  profilanswer
 

Bonjour,
 
j'ai écrit le code suivant en c il s'agit d'un correcteur orthographique:
 
 

Code :
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  6. short dichotomie(char **dico,char *mot_texte,int nbmots);
  7. void ajout(char **dico, char *mot_texte, int findico);
  8. char *sup_ponc(char *mot_texte);
  9. char *sup_maj(char *mot_texte);
  10. int compare_mots(const void *a, const void *b);
  11. void purger();
  13. #define MAXMOTS 100
  14. #define LONGMOT 20
  16. int main(int argc,char *argv[])
  17. {
  18. /*Déclarations des fichiers*/
  19. FILE *fichiertexte;
  20. FILE *fichierdico;
  22. /*Déclarations des variables*/
  23. int i,findico;
  24. char reponse[1];
  26. /*Déclarations des pointeurs*/
  27. char **dico;
  28. char *mot_texte;
  30. /*Allocation du pointeur *mot_texte*/
  31. mot_texte=malloc(LONGMOT*sizeof(char*));
  32. if (mot_texte==NULL)
  33. {
  34.   fprintf(stderr,"Allocation impossible \n" );
  35.   exit(EXIT_FAILURE);
  36. }
  38. /*Vérification du nombre d'arguments corrects à l'appel*/
  39. if (argc!=2)
  40.   {
  41.    printf("Erreur dans le nombre d'arguments\n" );
  42.    exit(EXIT_FAILURE);
  43.   }
  45. /*Ouverture des fichiers en lecture*/
  46. fichiertexte=fopen(argv[1],"r" );
  47. if (fichiertexte==NULL)
  48.   {
  49.    printf("Impossible d'ouvrir %s.\n", argv[1]);
  50.    exit(EXIT_FAILURE);
  51.   }
  52. fichierdico=fopen("dico.dat","r" );
  54. /*Lecture du fichier dico et stockage en mémoire dans le tabeau dico*/
  55. for(findico=0;!feof(fichierdico);findico++)
  56.   {
  57.    dico[findico]=malloc(LONGMOT*sizeof(char*));
  58.    fscanf(fichierdico,"%s",dico[findico]);
  59.    if (dico[findico]==NULL)
  60.     {
  61.      fprintf(stderr,"Allocation impossible \n" );
  62.      exit(EXIT_FAILURE);
  63.     }
  64.   }
  66. /*Fermeture du fichier dico.dat*/
  67. fclose(fichierdico);
  69. /*Tri du tableau dico*/
  70. qsort((char**)dico,MAXMOTS,LONGMOT,compare_mots);
  72. /*Lecture et traitement du fichier texte*/
  73. while(!feof(fichiertexte))
  74. {
  75.   fscanf(fichiertexte,"%s",mot_texte);
  76.   mot_texte=sup_ponc(mot_texte);
  77.   mot_texte=sup_maj(mot_texte);
  78.   if (dichotomie(dico,mot_texte,findico-1)==0)
  79.    {
  80.     printf("Le mot '%s' n'est pas dans le dictionnaire, voulez vous le rajouter (o/n) ?\n", mot_texte);
  81.     scanf("%s",reponse);
  82.     while((reponse[0]!='o') && (reponse[0]!='n'))
  83.      {
  84.       printf("Réponse invalide, recommencez\n" );
  85.       scanf("%s",reponse);
  86.       purger();
  87.      }
  88.     if(reponse[0]=='o') ajout(dico,mot_texte,findico);
  89.    }
  90. }
  92. /*Fermeture du fichier texte*/
  93. fclose(fichiertexte);
  95. /*Ouverture du fichier dico, écriture des éléments du tableau et fermeture*/
  96. fichierdico=fopen("dico.dat","w" );
  97. for(i=0;i<=findico;i++) fprintf(fichierdico,"%s",dico[i]);
  98. fclose(fichierdico);
  100. /*Libération des pointeurs en mémoire*/
  101. free(mot_texte);
  102. free(dico);
  104. return 0;
  105. }
  107. char *sup_ponc(char *mot)
  108. {
  109.   int lettre, lettresuiv;
  110.   for(lettre=0,lettresuiv=0;mot[lettresuiv];lettresuiv++)
  111.    {
  112.     mot[lettre]=mot[lettresuiv];
  113.     /* Si le caractère est une ponctuation, on l'ignore*/
  114.     if (ispunct(mot[lettresuiv])!=1) lettre++;
  115.    }
  116.   /*Pour terminer la chaîne:*/
  117.   mot[lettre]='\0';
  118.   return mot;
  119. }
  121. char *sup_maj(char *mot)
  122. {
  123.   int lettre;
  124.   for (lettre=0;mot[lettre];lettre++)
  125.    {
  126.     if (isupper(mot[lettre])) mot[lettre]=tolower(mot[lettre]);
  127.    }
  128.   return mot;
  129. }
  131. short dichotomie(char **dico,char *mot,int nbmots)
  132. {
  133. int i,j,k,x;
  134. i=0;
  135. j=nbmots;
  137.   /*Allocation du pointeur **dico*/
  138. for(x=0;x<=(nbmots+1);x++)
  139.   {
  140.    dico[x]=malloc(LONGMOT*sizeof(char*));
  141.    if (dico[x]==NULL)
  142.     {
  143.      fprintf(stderr,"Allocation impossible \n" );
  144.      exit(EXIT_FAILURE);
  145.     }
  146.   }
  148. while ((j-i)>1)
  149.   {
  150.    k=i+((j-i)/2);
  151.    if (((j-i)%2)==0) k++;
  152.    if (strcmp(mot,dico[k-1])==0) return 1;
  153.    if (strcmp(mot,dico[k-1])<0) j=(k-1);
  154.    else i=(k-1);
  155.   }
  156. if ((strcmp(dico[i],mot)==0) || (strcmp(dico[j],mot)==0)) return 1;
  157.   else return 0;
  158. }
  160. void ajout(char **dico,char *mot_texte,int findico)
  161. {
  162.   /*Si le le nombre de mots est supérieur à MAXMOTS, on affiche une erreur sinon on ajoute le mot a la fin du tableau*/
  163.   if(findico!=MAXMOTS)
  164.    {
  165.     dico[findico+1]=mot_texte;
  166.     findico++;
  167.    }
  168.   else
  169.    {
  170.     printf("Vous avez dépassé le nombre de mots maximal du dictionnaire" );
  171.     exit(EXIT_FAILURE);
  172.    }
  173.    /*On retri le tableau*/
  174.    qsort((char**)dico, MAXMOTS,LONGMOT,compare_mots);
  175. }
  177. int compare_mots(const void *chaine1, const void *chaine2)
  178. {
  179. return strcmp(chaine1,chaine2);
  180. }
  182. void purger(void)
  183. {
  184.   int c;
  185.   while ((c=getchar()) != '\n' && c != EOF)
  186.   {}
  187. }


 
Je compile avec gcc et il ne détecte aucune erreur, par contre l'exécution me donne une erreur de segmentation dès le lancement du programme. En utilisant gdb il me détecte une erreur sur cette ligne:
 
dico[findico]=malloc(LONGMOT*sizeof(char*));
 
Je ne vois pas le problème...  :pt1cable:
 
Merci d'avance pour votre aide ;)
jamsss


Message édité par jamsss le 02-12-2009 à 20:58:52
mood
Publicité
Posté le 02-12-2009 à 19:07:01  profilanswer
 

n°1946734
ptitchep
Posté le 02-12-2009 à 20:09:37  profilanswer
 

Salut

 

ton pointeur dico n'est pas initialisé donc dico[findico] plante. Il te manque un

 

dico = malloc ( longueur * sizeof(char**));

 

Et puis tu devrais faire ta vérification du pointeur avant de l'utiliser

Code :
  1. if (dico[findico] == NULL)
  2. {
  3.     //cas d'erreur
  4. }
  5. else
  6.     fscanf ...
 


Je ne suis pas sûr non plus que feof soit la bonne solution pour tester la fin du fichier, mieux vaudrait regarder le retour de fscanf (voire utiliser fgets). (Il faudrait que quelqu'un confirme pour feof)


Message édité par ptitchep le 02-12-2009 à 20:15:55

---------------
deluser --remove-home ptitchep
n°1949640
jamsss
Posté le 11-12-2009 à 19:04:25  profilanswer
 

Bonjour,
 
Suite à tes remarques j'ai pu régler (je pense) les erreurs de segmentation par contre maintenant j'ai un autre soucis c'est que mon tableau dico[] ne contient pas vraiment les mots du texte mais après un test avec un printf il contient plutôt des choses de ce style : 0+��j ou P+��j ... Inutile de dire que pour la comparaison avec les mots du texte c'est pas génial... Je remet le code:
 

Code :
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  6. short dichotomie(char **dico,char *mot_texte,short nbmots);
  7. void ajout(char **dico, char *mot_texte, int findico);
  8. char *sup_ponc(char *mot_texte);
  9. char *sup_maj(char *mot_texte);
  10. int compare_mots(const void *a, const void *b);
  11. void purger();
  13. #define MAXMOTS 100
  14. #define LONGMOT 20
  16. int main(int argc,char *argv[])
  17. {
  18. /*Déclarations des fichiers*/
  19. FILE *fichiertexte;
  20. FILE *fichierdico;
  22. /*Déclarations des variables*/
  23. int i,findico;
  24. char reponse;
  26. /*Déclarations des pointeurs*/
  27. char **dico;
  28. char *mot_texte;
  30. /*Allocation des pointeurs */
  31. mot_texte=malloc(MAXMOTS*sizeof(char *));
  32. dico=malloc(MAXMOTS*LONGMOT*sizeof(char *));
  33. if (mot_texte==NULL)
  34.   {
  35.    fprintf(stderr,"Allocation impossible \n" );
  36.    exit(EXIT_FAILURE);
  37.   }
  39. /*Vérification du nombre d'arguments corrects à l'appel*/
  40. if (argc!=2)
  41.   {
  42.    printf("Erreur dans le nombre d'arguments\n" );
  43.    exit(EXIT_FAILURE);
  44.   }
  46. /*Ouverture des fichiers en lecture*/
  47. fichiertexte=fopen(argv[1],"r" );
  48. if (fichiertexte==NULL)
  49.   {
  50.    printf("Impossible d'ouvrir %s.\n", argv[1]);
  51.    exit(EXIT_FAILURE);
  52.   }
  53. fichierdico=fopen("dico.dat","r" );
  55. /*Lecture du fichier dico et stockage en mémoire dans le tabeau dico*/
  56. for(findico=0;!feof(fichierdico);findico++)
  57.   {
  58.    dico[findico]=malloc(LONGMOT*sizeof(char));
  59.     if (dico[findico]==NULL)
  60.     {
  61.      fprintf(stderr,"Allocation impossible \n" );
  62.      exit(EXIT_FAILURE);
  63.     }
  64.    else fscanf(fichierdico,"%s",dico[findico]);
  65.    printf("%s\n",dico[findico]);
  66.   }
  68. /*Fermeture du fichier dico.dat*/
  69. fclose(fichierdico);
  71. /*Tri du tableau dico*/
  72. qsort((char**)dico,MAXMOTS,LONGMOT,compare_mots);
  74. /*Lecture et traitement du fichier texte*/
  75. while(!feof(fichiertexte))
  76. {
  77.   fscanf(fichiertexte,"%s",mot_texte);
  78.   mot_texte=sup_ponc(mot_texte);
  79.   mot_texte=sup_maj(mot_texte);
  80.   if (dichotomie(dico,mot_texte,findico-1)!=1)
  81.    {
  82.     printf("Le mot '%s' n'est pas dans le dictionnaire, voulez vous le rajouter (o/n) ?\n", mot_texte);
  83.     reponse=getchar();
  84.     purger();
  85.     while((reponse!='o') && (reponse!='n'))
  86.      {
  87.       printf("Réponse invalide, recommencez\n" );
  88.       reponse=getchar();
  89.       purger();
  90.      }
  91.     if(reponse=='o') ajout(dico,mot_texte,findico);
  92.    }
  93. }
  95. /*Fermeture du fichier texte*/
  96. fclose(fichiertexte);
  98. /*Ouverture du fichier dico, écriture des éléments du tableau et fermeture*/
  99. fichierdico=fopen("dico.dat","w" );
  100. for(i=0;i<=findico;i++) fprintf(fichierdico,"%s",dico[i]);
  101. fclose(fichierdico);
  103. /*Libération des pointeurs en mémoire*/
  104. free(mot_texte);
  105. for (i=0;i<findico;i++) free(dico[i]);
  107. return 0;
  108. }
  110. char *sup_ponc(char *mot)
  111. {
  112.   int lettre, lettresuiv;
  113.   for(lettre=0;mot[lettresuiv];lettre++)
  114.    {
  115.     lettresuiv=lettre+1;
  116.     /* Si le caractère est une ponctuation, on l'ignore*/
  117.     if (ispunct(mot[lettre])!=0) strcpy(&mot[lettre],&mot[lettresuiv]);
  118.    }
  119.   /*Pour terminer la chaîne:*/
  120.   mot[lettre]='\0';
  121.   return mot;
  122. }
  124. char *sup_maj(char *mot)
  125. {
  126.   int lettre;
  127.   for (lettre=0;mot[lettre];lettre++)
  128.    {
  129.     if (isupper(mot[lettre])) mot[lettre]=tolower(mot[lettre]);
  130.    }
  131.   return mot;
  132. }
  134. short dichotomie(char **dico,char *mot,short nbmots)
  135. {
  136. int i,j,k,x;
  137. j=nbmots;
  138. i=0;
  140.   /*Allocation du pointeur **dico*/
  141. for(x=0;x<=nbmots;x++)
  142.   {
  143.    dico[x]=malloc(LONGMOT*sizeof(char));
  144.    if (dico[x]==NULL)
  145.     {
  146.      fprintf(stderr,"Allocation impossible \n" );
  147.      exit(EXIT_FAILURE);
  148.     }
  149.   }
  151. while ((j-i)>1)
  152.   {
  153.    k=i+((j-i)/2);
  154.    if (((j-i)%2)==0) k++;
  155.    if (strcmp(mot,dico[k-1])==0) return 1;
  156.    if (strcmp(mot,dico[k-1])<0) j=(k-1);
  157.    else i=(k-1);
  158.   }
  159. printf("%s\n",dico[i]);
  160. printf("%s\n",mot);
  161. if ((strcmp(dico[i],mot)==0) || (strcmp(dico[j],mot)==0)) return 1;
  162.   else return 0;
  163. }
  165. void ajout(char **dico,char *mot_texte,int findico)
  166. {
  167.   /*Si le le nombre de mots est supérieur à MAXMOTS, on affiche une erreur sinon on ajoute le mot a la fin du tableau*/
  168.   if(findico!=MAXMOTS)
  169.    {
  170.     dico[findico+1]=mot_texte;
  171.     findico++;
  172.    }
  173.   else
  174.    {
  175.     printf("Vous avez dépassé le nombre de mots maximal du dictionnaire" );
  176.     exit(EXIT_FAILURE);
  177.    }
  178.    /*On retri le tableau*/
  179.    qsort((char**)dico, MAXMOTS,LONGMOT,compare_mots);
  180. }
  182. int compare_mots(const void *chaine1, const void *chaine2)
  183. {
  184. return strcmp(chaine1,chaine2);
  185. }
  187. void purger(void)
  188. {
  189.   int c;
  190.   while ((c=getchar()) != '\n' && c != EOF)
  191.   {}
  192. }


 
Merci
 
PS: feof marche bien pas de soucis de ce côté la ;)


Message édité par jamsss le 11-12-2009 à 19:07:21
n°1949733
jamsss
Posté le 12-12-2009 à 11:50:50  profilanswer
 

Le remplissage du tableau dico semble bon, le problème viendrai plutôt du qsort, quelqu'un à une idée ?

n°1949752
Trap D
Posté le 12-12-2009 à 14:58:29  profilanswer
 

Il faut donner la taille des éléments à échanger, donc c'est peut-être plutôt sizeof(char *) que LONGMOT. A tester bien entendu.

n°1949889
jamsss
Posté le 13-12-2009 à 18:39:45  profilanswer
 

oui en effet c'est bien ça j'ai vu ça entre temps, merci à toi ;)

n°1950680
jamsss
Posté le 16-12-2009 à 00:12:27  profilanswer
 

Bon le programme fonctionne presque... je n'ai plus d'erreur de segmentation mais j'ai un problème au niveau de la fonction "ajout" (elle sert à ajouter un mot à la fin du fichier dico en passant par le tableau dico si le mot du texte n'est pas existant). Donc cette fonction marche de temps en temps...
 
Exemple:
 
Voila le contenu du fichier texte:
 
http://ups.imagup.com/06/1260964416.jpg
 
Celui du fichier dico:
 
http://ups.imagup.com/06/1260964618.jpg
 
Et voila ce qu'il se passe
 
http://ups.imagup.com/06/1260965452.jpg
 
Le programme plante... Dans certains cas, ça passe (c'est sûrement du mot au mot ou bien au nombre de mots) j'ai tout essayé mais je ne comprends pas  :pfff:  :pfff:  :pfff: je remet le code complet:
 

Code :
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  6. short dichotomie(char **dico,char *mot_texte);
  7. void ajout(char **dico, char *mot_texte);
  8. char *sup_ponc(char *mot_texte);
  9. char *sup_maj(char *mot_texte);
  10. int compare_mots(const void *a, const void *b);
  11. void purger();
  12. int nbmots;
  14. #define MAXMOTS 100
  15. #define LONGMOT 20
  17. int main(int argc,char *argv[])
  18. {
  19. /*Déclarations des fichiers*/
  20. FILE *fichiertexte;
  21. FILE *fichierdico;
  23. /*Déclarations des variables*/
  24. int i,findico;
  25. char reponse;
  27. /*Déclarations des pointeurs*/
  28. char **dico;
  29. char *mot_texte;
  31. /*Allocation des pointeurs */
  32. mot_texte=malloc(MAXMOTS*sizeof(char *));
  33. dico=malloc(MAXMOTS*sizeof(char *));
  34. if (mot_texte==NULL)
  35.   {
  36.    fprintf(stderr,"Allocation impossible \n" );
  37.    exit(EXIT_FAILURE);
  38.   }
  40. /*Vérification du nombre d'arguments corrects à l'appel*/
  41. if (argc!=2)
  42.   {
  43.    printf("Erreur dans le nombre d'arguments\n" );
  44.    exit(EXIT_FAILURE);
  45.   }
  47. /*Ouverture des fichiers en lecture*/
  48. fichiertexte=fopen(argv[1],"r" );
  49. if (fichiertexte==NULL)
  50.   {
  51.    printf("Impossible d'ouvrir %s.\n", argv[1]);
  52.    exit(EXIT_FAILURE);
  53.   }
  54. fichierdico=fopen("dico.dat","r" );
  55. if (fichierdico==NULL)
  56.   {
  57.    printf("Impossible d'ouvrir le fichier dico.dat\n" );
  58.    exit(EXIT_FAILURE);
  59.   }
  61. /*Lecture du fichier dico et stockage en mémoire dans le tabeau dico*/
  62. for(i=0;i<MAXMOTS;i++)
  63.   {
  64.    dico[i]=malloc(LONGMOT*sizeof(char));
  65.     if (dico[i]==NULL)
  66.     {
  67.      fprintf(stderr,"Allocation impossible \n" );
  68.      exit(EXIT_FAILURE);
  69.     }
  70.   }
  71. for(findico=0;!feof(fichierdico);findico++) fscanf(fichierdico,"%s",dico[findico]);
  72. nbmots=findico-1;
  74. /*Fermeture du fichier dico.dat*/
  75. fclose(fichierdico);
  77. /*Tri du tableau dico*/
  78. qsort(dico,nbmots,sizeof *dico,compare_mots);
  80. /*Lecture et traitement du fichier texte*/
  81. while(!feof(fichiertexte))
  82. {
  83.   fscanf(fichiertexte,"%s",mot_texte);
  84.   mot_texte=sup_ponc(mot_texte);
  85.   mot_texte=sup_maj(mot_texte);
  86.   if (dichotomie(dico,mot_texte)==0)
  87.    {
  88.     printf("Le mot '%s' n'est pas dans le dictionnaire, voulez vous le rajouter (o/n) ?\n", mot_texte);
  89.     reponse=getchar();
  90.     purger();
  91.     while((reponse!='o') && (reponse!='n'))
  92.      {
  93.       printf("Réponse invalide, recommencez\n" );
  94.       reponse=getchar();
  95.       purger();
  96.      }
  97.     if(reponse=='o')
  98.      {
  99.       ajout(dico,mot_texte);
  100.       /*Ouverture du fichier dico, écriture des éléments du tableau et fermeture*/
  101.       fichierdico=fopen("dico.dat","w" );
  102.       for(i=0;i<nbmots-1;i++) fprintf(fichierdico,"%s ",dico[i]);
  103.       fprintf(fichierdico,"%s",dico[nbmots-1]);
  104.       fclose(fichierdico);
  105.      }
  106.    }
  107.   }
  109. /*Fermeture du fichier texte*/
  110. fclose(fichiertexte);
  112. /*Libération des pointeurs en mémoire*/
  113. free(mot_texte);
  114. for (i=0;i<findico;i++) free(dico[i]);
  116. return 0;
  117. }
  119. char *sup_ponc(char *mot)
  120. {
  121.   int lettre, lettresuiv;
  122.   for(lettre=0, lettresuiv=0;mot[lettresuiv];lettre++)
  123.    {
  124.     lettresuiv=lettre+1;
  125.     /* Si le caractère est une ponctuation, on l'ignore*/
  126.     if (ispunct(mot[lettre])!=0) strcpy(&mot[lettre],&mot[lettresuiv]);
  127.    }
  128.   /*Pour terminer la chaîne:*/
  129.   mot[lettre]='\0';
  130.   return mot;
  131. }
  133. char *sup_maj(char *mot)
  134. {
  135.   int lettre;
  136.   for (lettre=0;mot[lettre];lettre++)
  137.    {
  138.     if (isupper(mot[lettre])) mot[lettre]=tolower(mot[lettre]);
  139.    }
  140.   return mot;
  141. }
  143. short dichotomie(char **dico,char *mot)
  144. {
  145. int i,j,k;
  146. j=nbmots;
  147. i=0;
  149. while ((j-i)>1)
  150.   {
  151.    k=i+((j-i)/2);
  152.    if (((j-i)%2)==0) k++;
  153.    if (strcmp(mot,dico[k-1])==0) return 1;
  154.    if (strcmp(mot,dico[k-1])<0) j=(k-1);
  155.    else i=(k-1);
  156.   }
  158. if ((strcmp(dico[i],mot)==0) || (strcmp(dico[j],mot)==0)) return 1;
  159. else return 0;
  160. }
  162. void ajout(char **dico,char *mot_texte)
  163. {
  164.   /*Si le le nombre de mots est supérieur à MAXMOTS, on affiche une erreur sinon on ajoute le mot a la fin du              tableau*/
  165.    if(nbmots!=MAXMOTS)
  166.     {
  167.      nbmots++;
  168.      strcpy(dico[nbmots-1],mot_texte);
  169.     }
  170.    else
  171.     {
  172.      printf("Vous avez dépassé le nombre de mots maximal du dictionnaire" );
  173.      exit(EXIT_FAILURE);
  174.     }
  175.   /*On retri le tableau*/
  176.    qsort(dico,nbmots,sizeof *dico,compare_mots);
  177. }
  179. int compare_mots(const void *chaine1, const void *chaine2)
  180. {
  181. return strcmp(*(char**)chaine1,*(char**)chaine2);
  182. }
  184. void purger(void)
  185. {
  186.   int c;
  187.   while ((c=getchar()) != '\n' && c != EOF)
  188.   {}
  189. }


 
J'espere que quelqu'un pourra m'aider parce que la je vais pas tarder à péter un câble  :pt1cable:  :pt1cable:  :pt1cable:  
Merci d'avance


Message édité par jamsss le 16-12-2009 à 00:47:39
n°1950684
ptitchep
Posté le 16-12-2009 à 01:37:52  profilanswer
 

Utilise un debugger et vérifie ta dichotomie  ;)  
 
En vrac:
berk les variables globales.
 
inutile de créer ton tableau dynamiquement si c'est pour lui donner la taille d'un #define
dico[MAXMOTS][LONGMOT]
revient au même dans ce cas.
 
malloc => free (il en manque un je crois)
 
fscanf fgets
 
...


---------------
deluser --remove-home ptitchep
n°1950997
jamsss
Posté le 16-12-2009 à 18:34:34  profilanswer
 

Tout d'abord merci de ton aide, pour te répondre:
 
-La fonction dichotomie marche je l'ai deja testée et le debugger ne me dit rien puisque le programme reste planté sans erreur..
-berk les variables globales je suis d'accord avec toi , c'était juste pour faire un test et je l'ai laissé en fait...
-Pour le tableau dynamique c'est vrai, au départ je voulais le faire mais je l'ai enlevé pour éviter les sources d'erreur
-Ah oui c'est vrai il manque un free, je l'ai mis mais ça ne résout pas le problème malheureusement...

n°1951007
ptitchep
Posté le 16-12-2009 à 20:08:28  profilanswer
 

moi j'ai passé un coup de debugger et arrivé au mot "est", la fonction dichotomie tourne en boucle infinie. Je n'ai pas cherché pourquoi.


---------------
deluser --remove-home ptitchep
mood
Publicité
Posté le 16-12-2009 à 20:08:28  profilanswer
 

n°1951010
jamsss
Posté le 16-12-2009 à 20:44:51  profilanswer
 

oui c'est ce que je redoutais... en fait j'avais crée et testé cette fonction dichotomie avant le code complet et j'avais déja eu ce souci de boucle infinie mais j'avais rajouté cette ligne:
 
if (((j-i)%2)==0) k++;
 
Je croyais avoir résolu le problème puisque ça fonctionnait, apparement maintenant ça ne fonctionne plus

n°1951025
jamsss
Posté le 16-12-2009 à 22:19:50  profilanswer
 

bon en fait j'ai trouvé il se trouve que contrairement aux apparences i+((j-i)/2) n'est pas équivalent à (i+j)/2...........et que je suis un gros boulet  :bounce:  :bounce:  :bounce:  :bounce:  :ange:

Message cité 1 fois
Message édité par jamsss le 16-12-2009 à 23:08:43
n°1951032
ptitchep
Posté le 16-12-2009 à 23:31:38  profilanswer
 

jamsss a écrit :

bon en fait j'ai trouvé il se trouve que contrairement aux apparences i+((j-i)/2) n'est pas équivalent à (i+j)/2


Vive les entiers...

jamsss a écrit :

...........et que je suis un gros boulet  :bounce:  :bounce:  :bounce:  :bounce:  :ange:

Rassure toi, c'est souvent sur les erreurs les plus stupides que l'on passe le plus de temps...


---------------
deluser --remove-home ptitchep

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  [c] erreur de segmentation

 

Sujets relatifs
[résolu][C] Strlen - erreur de segmentation[ C ] Erreur de segmentation (core dumped)
Courbes avec Qwt (erreur de segmentation)Erreur de segmentation avec un main vide
Ou est l'erreur de segmentation ?Erreur de Segmentation
Erreur de segmentation incompréhensibleerreur de segmentation
"erreur de segmentation" avec les threads sous linux en C++Erreur de segmentation
Plus de sujets relatifs à : [c] erreur de segmentation

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.182 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR