[c] erreur de segmentation

erreur de segmentation [c] - C - Programmation

Marsh Posté le 02-12-2009 à 19:07:01    

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
Reply

Marsh Posté le 02-12-2009 à 19:07:01   

Reply

Marsh Posté le 02-12-2009 à 20:09:37    

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
Reply

Marsh Posté le 11-12-2009 à 19:04:25    

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
Reply

Marsh Posté le 12-12-2009 à 11:50:50    

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

Reply

Marsh Posté le 12-12-2009 à 14:58:29    

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

Reply

Marsh Posté le 13-12-2009 à 18:39:45    

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

Reply

Marsh Posté le 16-12-2009 à 00:12:27    

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
Reply

Marsh Posté le 16-12-2009 à 01:37:52    

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
Reply

Marsh Posté le 16-12-2009 à 18:34:34    

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...

Reply

Marsh Posté le 16-12-2009 à 20:08:28    

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
Reply

Marsh Posté le 16-12-2009 à 20:08:28   

Reply

Marsh Posté le 16-12-2009 à 20:44:51    

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

Reply

Marsh Posté le 16-12-2009 à 22:19:50    

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
Reply

Marsh Posté le 16-12-2009 à 23:31:38    

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
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed