Tableau dynamique de caractères

Tableau dynamique de caractères - C - Programmation

Marsh Posté le 22-11-2006 à 07:54:36    

Bonjour,  
 
voilà je commence à toucher un petit peu aux pointeurs, et j'ai un petit problème avec le programme suivant. Il est censé permettre la saisie d'une liste de nom, les trier puis les afficher par ordre alphabétque.
 
Le soucis c'est que lors de la saisie (juste après que je rentre le nombre de nom à saisir) et bien le gets me saute la saisie d'un nom
 
au lieu d'afficher
 
Entrez le nom a saisir :  
 
 
il me fait
 
Entrez le nom a saisir :  
Entrez le nom a saisir :  
 
 
et donc au lancement de la boucle je perds la saisie d'un nom. Je sais pas si j'ai été assez clair.
 
voilà le programme, si quelqu'un pouvait me filer un ptit coup de main pour trouver ce qui ne vas pas
 
Merci
 

Code :
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. int main (void)
  7. {
  8. char **noms;
  9. char tempo[20];
  10. int nombre_noms, i, j;
  12. clrscr();
  14. printf("Entrez le nombre de noms a saisir : " );
  15. scanf("%d", &nombre_noms);
  17. noms = (char**) malloc(nombre_noms * sizeof(char*));
  20. /* Saisie + Allocation mémoire */
  22. for (i = 0; i < nombre_noms; i++)
  23. {
  24.  printf("\nEntrez le nom a saisir : " );
  25.  gets(tempo);
  26.         noms[i] = (char*) malloc(strlen(tempo) + 1);
  27.  strcpy(noms[i], strupr(tempo));
  28. }
  31. /* Tri des elements du tableau */
  33. for (i = 0; i < nombre_noms - 1; i++)
  34.  for (j = i + 1; j < nombre_noms; j++)
  35.   if (strcmp(noms[i], noms[j]) > 0)
  36.   {
  37.    strcpy(tempo, noms[i]);
  38.    strcpy(noms[i], noms[j]);
  39.    strcpy(noms[j], tempo);
  40.  }
  43. /* Affichage des elements du tableau */
  45. for (i = 0; i < nombre_noms; i++)
  46.  printf("\n%s", noms[i]);
  48. getch();
  50. return 0;
  51. }

Message cité 1 fois
Reply

Marsh Posté le 22-11-2006 à 07:54:36   

Reply

Marsh Posté le 22-11-2006 à 08:13:14    

Tu cumules deux problèmes :
- L'utilisation de scanf qui est TRES difficile mais faisable.
- L'utilisation de gets qui est déconseillée puisque gets est un bug (pas de test sur la longueur de la chaine saisie), il faut utiliser fgets(tempo, sizeof tempo, stdin).
Ton problème vient du fait que scanf laisse dans le buffer de saisie le '\n', et donc que la première chose lue par le gets est ce '\n', tu dois vider le buffer de saisie par un while ((c = fgetc(stdin)) != '\n') ;
   
 

Message cité 1 fois
Reply

Marsh Posté le 22-11-2006 à 08:13:27    

exhortae a écrit :

voilà je commence à toucher un petit peu aux pointeurs, et j'ai un petit problème avec le programme suivant. Il est censé permettre la saisie d'une liste de nom, les trier puis les afficher par ordre alphabétque.

 

Le soucis c'est que lors de la saisie (juste après que je rentre le nombre de nom à saisir) et bien le gets me saute la saisie d'un nom


Il ne faut pas utiliser gets(). Les saisies en C demandent de l'attention.

 

Je recommande une utilisation exclusive et maitrisée de fgets().

 

http://mapage.noos.fr/emdel/notes.htm#saisie
http://mapage.noos.fr/emdel/notes.htm#fichiers

 

Ton code commenté et corrigé. Bien lire les commentaires (-ed-) et poser des questions si nécessaire.

Code :
  1. #include <stdio.h>
  3. /* -ed-
  4. #include <conio.h>
  6. non standard et probablement inutile pour le probleme a resoudre
  7. */
  8. #include <stdlib.h>
  9. #include <string.h>
  11. /* fonction de nettoyage a appeler apres un fgets */
  12. static void fclean (char *s, FILE * fp)
  13. {
  14.    /* search the end of line marker */
  15.    char *p = strchr (s, '\n');
  17.    if (p != NULL)
  18.    {
  19.       /* found : shoot it */
  20.       *p = 0;
  21.    }
  22.    else
  23.    {
  24.       int c;
  25.       /* not found : purge the pending characters in the incoming stream */
  26.       while ((c = fgetc (fp)) != '\n' && c != EOF)
  27.       {
  28.       }
  29.    }
  30. }
  32. int main (void)
  33. {
  34.    /* -ed-
  35.       char **noms;
  36.       int nombre_noms, i, j;
  38.       Je conseille de reduire la porte des objets et fonctions au strict necessaire
  40.       size_t est le bon type pour les tailles et les indices croissants
  41.     */
  42.    size_t nombre_noms;
  44. /* -ed-
  45. clrscr();
  47. non standard et probablement inutile pour le probleme a resoudre
  48. */
  50.    printf ("Entrez le nombre de noms a saisir : " );
  52.    /* -ed-
  53.       scanf ("%d", &nombre_noms);
  55.       Un usage incorrect de scanf() entraine des comportements instables du
  56.       programme, comme ceux constates. L'usage correct de scanf() est assez difficile.
  57.       Je recommande un usage maitrise et exclusif de fgets().
  58.     */
  59.    {
  60.       char s[8];
  61.       fgets (s, sizeof s, stdin);
  62.       fclean (s, stdin);
  63.       /* -ed- simpliste, mais suffisant pour le moment */
  64.       nombre_noms = (size_t) strtol (s, NULL, 10);
  65.    }
  67. /* -ed-
  68.    noms = (char **) malloc (nombre_noms * sizeof (char *));
  70.    Correct, mais inutilement complexe.
  71.    Par contre, il manque l'essentiel. malloc() peut echouer.
  72. */
  73.    {
  74.       char **noms = malloc (nombre_noms * sizeof *noms);
  76.       if (noms != NULL)
  77.       {
  78.          /* Saisie + Allocation mémoire */
  79.          {
  80.             size_t i;
  81.             for (i = 0; i < nombre_noms; i++)
  82.             {
  83.                char tempo[20];
  84.                printf ("\nEntrez le nom a saisir : " );
  85.                /* -ed-
  86.                   gets (tempo);
  88.                   cette fonction est dangereuse. Il n'est pas possible de limiter
  89.                   le nombre de caracteres entres. Un debordement memoire est
  90.                   toujours possible.
  92.                   fgets() resout ce probleme.
  93.                 */
  95.                fgets (tempo, sizeof tempo, stdin);
  96.                fclean (tempo, stdin);
  98.                /* -ed
  99.                   noms[i] = (char *) malloc (strlen (tempo) + 1);
  100.                 */
  101.                noms[i] = malloc (strlen (tempo) + 1);
  103.                /* -ed- attention strupr() n'est pas standard */
  104.                strcpy (noms[i], strupr (tempo));
  105.             }
  106.          }
  108.          /* Tri des elements du tableau */
  110.          {
  111.             size_t i;
  112.             /* -ed- je recommande l'usage systematique des { }
  113.                avec les structures de code
  114.              */
  115.             for (i = 0; i < nombre_noms - 1; i++)
  116.             {
  117.                size_t j;
  118.                for (j = i + 1; j < nombre_noms; j++)
  119.                {
  120.                   /* -ed- attention, malloc() a pu echouer.
  121.                      Il peut y avoir des pointeurs NULL
  122.                    */
  123.                   if (noms[i] != NULL && noms[j] != NULL)
  124.                   {
  125.                      if (strcmp (noms[i], noms[j]) > 0)
  126.                      {
  127.                         char tempo[20];
  128.                         strcpy (tempo, noms[i]);
  129.                         strcpy (noms[i], noms[j]);
  130.                         strcpy (noms[j], tempo);
  131.                      }
  132.                   }
  133.                }
  134.             }
  135.          }
  136.          /* Affichage des elements du tableau */
  137.          {
  138.             size_t i;
  139.             for (i = 0; i < nombre_noms; i++)
  140.                if (noms[i] != NULL)
  141.                {
  142.                   printf ("\n%s", noms[i]);
  143.                }
  144.          }
  145. /* -ed-
  146. getch();
  148. non standard et probablement inutile pour le probleme a resoudre
  149. */
  151. /* -ed- ce qui a ete alloue doit etre libere */
  153.          {
  154.             size_t i;
  155.             for (i = 0; i < nombre_noms; i++)
  156.             {
  157.                free (noms[i]), noms[i] = NULL;
  158.             }
  159.          }
  160.          free (noms), noms = NULL;
  161.       }
  162.    }
  163.    return 0;
  164. }


Le fonctionnement est maintenant conforme :


Entrez le nombre de noms a saisir : 4

 

Entrez le nom a saisir : ljksd lkjsd

 

Entrez le nom a saisir : jkdfi ds

 

Entrez le nom a saisir : unazlmdj kclkds

 

Entrez le nom a saisir : sdf ryuihdf

 

JKDFI DS
LJKSD LKJSD
SDF RYUIHDF
UNAZLMDJ KCLKDS
Press ENTER to continue.


Mais le tri est améliorable. En effet, on a un tableau de pointeurs. Il suffit donc d'échanger les pointeurs au lieu des chaines, ce sera bien plus rapide.

 

Enfin, le code, tel qu'il est présenté maintenant grâce à la réduction massive de la portée des variables, peut être découpé facilement en fonctions, ce qui le rendra nettement plus clair, en introduisant un nouveau niveau d'abstraction.

 
Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. /* fonction de nettoyage a appeler apres un fgets */
  6. static void fclean (char *s, FILE * fp)
  7. {
  8.    /* search the end of line marker */
  9.    char *p = strchr (s, '\n');
  11.    if (p != NULL)
  12.    {
  13.       /* found : shoot it */
  14.       *p = 0;
  15.    }
  16.    else
  17.    {
  18.       int c;
  19.       /* not found : purge the pending characters in the incoming stream */
  20.       while ((c = fgetc (fp)) != '\n' && c != EOF)
  21.       {
  22.       }
  23.    }
  24. }
  26. static void trier (char **noms, size_t nombre_noms)
  27. {
  28.    size_t i;
  30.    for (i = 0; i < nombre_noms - 1; i++)
  31.    {
  32.       size_t j;
  33.       for (j = i + 1; j < nombre_noms; j++)
  34.       {
  35.          if (noms[i] != NULL && noms[j] != NULL)
  36.          {
  37.             if (strcmp (noms[i], noms[j]) > 0)
  38.             {
  39.                char *tempo = noms[i];
  40.                noms[i] = noms[j];
  41.                noms[j] = tempo;
  42.             }
  43.          }
  44.       }
  45.    }
  46. }
  48. static void afficher (char **noms, size_t nombre_noms)
  49. {
  50.    size_t i;
  51.    for (i = 0; i < nombre_noms; i++)
  52.       if (noms[i] != NULL)
  53.       {
  54.          printf ("\n%s", noms[i]);
  55.       }
  56. }
  58. static void liberer (char **noms, size_t nombre_noms)
  59. {
  60.    size_t i;
  61.    for (i = 0; i < nombre_noms; i++)
  62.    {
  63.       free (noms[i]), noms[i] = NULL;
  64.    }
  65.    free (noms), noms = NULL;
  66. }
  68. int main (void)
  69. {
  70.    size_t nombre_noms;
  72.    printf ("Entrez le nombre de noms a saisir : " );
  74.    {
  75.       char s[8];
  76.       fgets (s, sizeof s, stdin);
  77.       fclean (s, stdin);
  78.       /* -ed- simpliste, mais suffisant pour le moment */
  79.       nombre_noms = (size_t) strtol (s, NULL, 10);
  80.    }
  82.    {
  83.       char **noms = malloc (nombre_noms * sizeof *noms);
  85.       if (noms != NULL)
  86.       {
  87.          /* Saisie + Allocation mémoire */
  88.          {
  89.             size_t i;
  90.             for (i = 0; i < nombre_noms; i++)
  91.             {
  92.                char tempo[20];
  93.                printf ("Entrez le nom a saisir : " );
  94.                fflush (stdout);
  95.                fgets (tempo, sizeof tempo, stdin);
  96.                fclean (tempo, stdin);
  98.                noms[i] = malloc (strlen (tempo) + 1);
  100.                /* -ed- attention strupr() n'est pas standard */
  101.                strcpy (noms[i], strupr (tempo));
  102.             }
  103.          }
  105.          /* Tri des elements du tableau */
  106.          trier (noms, nombre_noms);
  108.          /* Affichage des elements du tableau */
  109.          afficher (noms, nombre_noms);
  111.          /* liberation du tableau */
  112.          liberer (noms, nombre_noms), noms = NULL;
  113.       }
  114.    }
  115.    return 0;
  116. }


On pourrait aller plus loin dans l'abstraction, mais pour le moment, ça devrait suffire.

 

Pose des questions si tu ne comprends pas.

Message cité 1 fois
Message édité par Emmanuel Delahaye le 22-11-2006 à 09:15:51

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 22-11-2006 à 20:51:27    

Trap D a écrit :

Tu cumules deux problèmes :
- L'utilisation de scanf qui est TRES difficile mais faisable.
- L'utilisation de gets qui est déconseillée puisque gets est un bug (pas de test sur la longueur de la chaine saisie), il faut utiliser fgets(tempo, sizeof tempo, stdin).
Ton problème vient du fait que scanf laisse dans le buffer de saisie le '\n', et donc que la première chose lue par le gets est ce '\n', tu dois vider le buffer de saisie par un while ((c = fgetc(stdin)) != '\n') ;


 
Merci

Reply

Marsh Posté le 22-11-2006 à 20:53:09    

Emmanuel Delahaye a écrit :

On pourrait aller plus loin dans l'abstraction, mais pour le moment, ça devrait suffire.
 
Pose des questions si tu ne comprends pas.


 
Vraiment un grand merci à toi d'avoir pris autant de temps pour me répondre,
 
je potasse ça à tête reposée et je reviens ;)
 
 
encore une fois merci :)

Reply

Marsh Posté le 23-11-2006 à 23:01:21    

Me revoilà :)
 
voilà j'ai lu, et essayer d'appliquer (en partie pour commencer), tes conseils.
 
je n'ai pas suivi toutes le recommandations parceque j'aimerais y aller progressivement, voilà j'ai réecri le programme une première fois, si tu pouvais d'abord me dire si c'est correct (par si c'est correct j'entends si il n'y a pas d'erreur, pas si certaines chose sont manquantes ;)). Ensuite j'aimerais te poser dessus quelques questions si tu veux bien.
 
Merci
 

Code :
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. int main (void)
  6. {
  7. size_t nombre_noms;
  9. printf ("Entrez le nombre de noms a saisir : " );
  11. {
  12.  char s[8];
  14.  fgets (s, sizeof s, stdin);
  15.  nombre_noms = (size_t) strtol (s, NULL, 10);
  16. }
  18. {
  19.  char **noms = malloc (nombre_noms * sizeof *noms);
  21.  if (noms != NULL)
  22.  {
  23.   {
  24.    size_t i;
  26.    printf ("\n\n" );
  27.    for (i = 0; i < nombre_noms; i++)
  28.    {
  29.     char tempo[20];
  31.     printf("Entrez le nom a saisir : " );
  32.     fgets (tempo, sizeof tempo, stdin);
  34.     noms[i] = malloc (strlen (tempo + 1));
  36.     strcpy (noms[i], strupr(tempo));
  38.    }
  39.    printf ("\n\n" );
  40.   }
  42.   /* TRI */
  44.   {
  45.    size_t i;
  46.    for (i = 0; i < nombre_noms - 1; i++)
  47.    {
  48.     size_t j;
  49.     for (j = i + 1; j < nombre_noms; j++)
  50.     {
  51.      if (strcmp (noms[j], noms[i]) < 0)
  52.      {
  53.       char tempo[20];
  54.       strcpy (tempo, noms[i]);
  55.       strcpy (noms[i], noms[j]);
  56.       strcpy (noms[j], tempo);
  57.      }
  58.     }
  59.    }
  60.   }
  62.   /* AFFICHAGE */
  64.   {
  65.    size_t i;
  67.    for (i = 0; i < nombre_noms; i++)
  68.     printf("%s", noms[i]);
  69.   }
  70.  }
  71. }
  73.     return 0;
  74. }

Message cité 1 fois
Message édité par exhortae le 23-11-2006 à 23:03:32
Reply

Marsh Posté le 23-11-2006 à 23:47:47    

exhortae a écrit :

je n'ai pas suivi toutes le recommandations parceque j'aimerais y aller progressivement, voilà j'ai réecri le programme une première fois, si tu pouvais d'abord me dire si c'est correct (par si c'est correct j'entends si il n'y a pas d'erreur, pas si certaines chose sont manquantes ;)).  


 
Le fonctionnement est correct, mais la mémoire n'est pas libérée. Si je passe ton code au détecteur de mensonges :  


Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
Entrez le nombre de noms a saisir : 4
 
 
Entrez le nom a saisir : azert
Entrez le nom a saisir : qsdfg
Entrez le nom a saisir : wxcvb
Entrez le nom a saisir : tyuio
 
 
AZERT
QSDFG
TYUIO
WXCVB
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D24E8 (16 bytes) malloc'ed at line 23 of 'main.c' not freed
SYSALLOC Bloc 003D2478 (5 bytes) malloc'ed at line 38 of 'main.c' not freed
SYSALLOC Bloc 003D2468 (5 bytes) malloc'ed at line 38 of 'main.c' not freed
SYSALLOC Bloc 003D2500 (5 bytes) malloc'ed at line 38 of 'main.c' not freed
SYSALLOC Bloc 003D2510 (5 bytes) malloc'ed at line 38 of 'main.c' not freed
SYSALLOC Released Memory
FRMWRK.Termine
 
Press ENTER to continue.


Il avoue n'avoir pas libérer la mémoire...

Citation :

Ensuite j'aimerais te poser dessus quelques questions si tu veux bien.


OK.


---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 24-11-2006 à 15:18:33    

Bonjour,
 
alors j'ai d'abord une question sur les fonctions d'entrée en c.
 
Voilà je vais commencer à utiliser fgets à la place de scanf.  
Si j'ai bien compris après un fgets il faut utiliser ta fontion fclean (pour vider le flux stdin ??), et c'est la où j'ai un problème, j'ai pas très bien saisie le principe de ta fonction fclean.
 
La fonction prends comme paramètre la chaine que j'ai récupérer avec fgets, et le flux (stdin dans mon cas), Mais l'autre paramètre (FILE * fp) j'ai pas saisi ce que c'est.
 
2) toujours dans la fonction fclean,
 

Code :
  1. char *p = strchr (s, '\n');


 
est-ce que ça veut dire je recherche la sous chaine \n dans la chaine s, et je l'affecte à p le cas échéant???
 
3) dans  

Code :
  1. if (p != NULL)
  2. {
  3.    *p = 0;
  4. }
  5. else
  6. {
  7.    int c;
  8.    while ((c = fgetc (fp)) != '\n' && c!= EOF)
  9. }


la première condition signifie si dans la chaine s  il y a le caractère '\n', *p = 0
 
mais concrètement ça veut dire quoi *p = 0;
 
et ce qu'il y a dans le else pour être honnête j'ai rien compris :)
 
Merci
 
 
PS : pendant que j'y suis , tu connaitrais un editeur, compilateur exécuteur pour le c sous windows.
Un truc avec une interface à peu près potable (pas comme turbo c 2.x et son interface rébarbative sur un lcd)

Message cité 1 fois
Message édité par exhortae le 24-11-2006 à 15:22:01
Reply

Marsh Posté le 24-11-2006 à 15:33:29    

exhortae a écrit :

Voilà je vais commencer à utiliser fgets à la place de scanf.


Bonne idée.

Citation :

Si j'ai bien compris après un fgets il faut utiliser ta fontion fclean (pour vider le flux stdin ??),


entre autres...

Citation :

et c'est la où j'ai un problème, j'ai pas très bien saisie le principe de ta fonction fclean.


Attention, j'ai mis 10 à mettre au point cet algorithme :

 

"Chercher  le '\n. Si il est présent, l'éliminer, sinon lire les caractères non lus sans les stocker."

 

Puissant, non ?

 

Pour les détails d'implémentation, je suggère que tu lises la doc des fonctions. (livre de C, man, help, F1, google...)

 
Citation :

la première condition signifie si dans la chaine s  il y a le caractère '\n', *p = 0


Yo !

Citation :

mais concrètement ça veut dire quoi *p = 0;


A ton avis ? Vraiment aucune idée ?

 

EDIT: je voudrais pas dire, mais mon code était commenté. Tu ne comprends pas l'anglais ? Pas d'informatique sans savoir lire l'anglais.

 
Citation :

tu connaitrais un editeur, compilateur exécuteur pour le c sous windows.


Je recommande Code::Blocks http://www.codeblocks.org/

Message cité 1 fois
Message édité par Emmanuel Delahaye le 24-11-2006 à 15:59:32

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 25-11-2006 à 20:27:58    

Emmanuel Delahaye a écrit :

je voudrais pas dire, mais mon code était commenté. Tu ne comprends pas l'anglais ? Pas d'informatique sans savoir lire l'anglais.
 


 
Je me débrouille plutôt bien en anglais, c'est juste qu'avec les pointeurs, j'ai du mal, mais là c'est bon, j'ai saisie la fonction et je suis capable de la refaire sans l'avoir apprise.
 
sinon voilà j'ai essayé d'appliquer tes conseils en faisant un ptit programme qui conjuge certains verbes du premier groupe, par contre j'ai du mal au niveau du main(), lorsque j'utilise une procédure qui devrait me permettre de tronquer mon verbe. c'est la procédure tronquer qui recoit comme paramètre une chaine de caractère et renvoie la chaine de caractère tronquée, y doit y avoir un soucis de pointeur :/
 
voilà le code
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. static void fclean(char *s, FILE *fp)
  6. {
  7. char *p = strchr (s, '\n');
  9. if (p != NULL)
  10. {
  11.  *p = 0;
  12. }
  13. else
  14. {
  15.  int c;
  16.  while ((c = fgetc(fp)) != '\n' && c != EOF)
  17.  {
  18.  }
  19. }
  20. }
  22. int verification_groupe_1 (char *verbe)
  23. {
  24. size_t longueur_verbe;
  25. int groupe_1;
  27. longueur_verbe = strlen (verbe);
  29. if (verbe[longueur_verbe - 1] == 'r' || verbe[longueur_verbe - 1] == 'R')
  30. {
  31.  if (verbe[longueur_verbe - 2] == 'e' || verbe[longueur_verbe - 2] == 'E')
  32.  {
  33.   return 1;
  34.  }
  35. }
  36. else
  37. {
  38.  return 0;
  39. }
  40. }
  42. static void conjugaison (char *verbe)
  43. {
  44. printf ("\n\nJe %se\n", verbe);
  45. printf ("Tu %se\n", verbe);
  46. printf ("Il, Elle, on %se\n", verbe);
  47. printf ("Nous %sons\n", verbe);
  48. printf ("Vous %sez\n", verbe);
  49. printf ("Ils, Elles %sent\n", verbe);
  50. }
  52. static void tronquer (char *verbe, char **verbe_tronque)
  53. {
  54. verbe[strlen (verbe) - 2] = '\0';
  56. strcpy (*verbe_tronque, verbe);
  57. }
  59. int main (void)
  60. {
  61. char verbe[20];
  63. printf ("Entrez un verbe : " );
  64. fgets (verbe, sizeof verbe, stdin);
  65. fclean (verbe, stdin);
  67. {
  68.  int groupe_1;
  70.  groupe_1 = verification_groupe_1 (verbe);
  72.  if (groupe_1 == 1)
  73.  {
  74.      tronquer (verbe, &verbe);
  75.   conjugaison (verbe);
  76.  }
  77.  else
  78.  {
  79.   printf ("\nLe verbe n'est pas un verbe du 1er groupe\n" );
  80.  }
  81. }
  82. return 0;
  83. }


Message cité 1 fois
Reply

Marsh Posté le 25-11-2006 à 20:27:58   

Reply

Marsh Posté le 25-11-2006 à 20:50:39    

Après recherche plus poussée et différents essais, j'ai remplacer mon main () par ça, et là ça marche, par contre je me demande si c'est correct.
 

Code :
  1. int main (void)
  2. {
  3. char verbe[20];
  4. char *p;
  6. p = verbe;
  8. printf ("Entrez un verbe : " );
  9. fgets (verbe, sizeof verbe, stdin);
  10. fclean (verbe, stdin);
  12. {
  13.  int groupe_1;
  15.  groupe_1 = verification_groupe_1 (verbe);
  17.  if (groupe_1 == 1)
  18.  {
  19.      tronquer (verbe, &p);
  20.   conjugaison (p);
  21.  }
  22.  else
  23.  {
  24.   printf ("\nLe verbe n'est pas un verbe du 1er groupe\n" );
  25.  }
  26. }
  27. return 0;

Reply

Marsh Posté le 26-11-2006 à 01:32:57    

exhortae a écrit :


Code :
  1. char verbe[20];
  2.     char *p;
  3.     p = verbe;
  5. static void tronquer (char *verbe, char **verbe_tronque)
  6. {
  7. verbe[strlen (verbe) - 2] = '\0';
  9. strcpy (*verbe_tronque, verbe);
  10. }



Interdit. Tu n'a pas le droit d'utiliser strcpy() sur le le même tableau. Pour ça, il faut utiliser memmove(). (Lire la doc de ces deux fonctions pour les détails).

 

Je ne vois pas pourquoi tu passes l'adresse du pointeur. Tu ne le modifie pas. C'est l'objet pointé que tu modifies. Tu peux donc écrire (le strcpy() reste faux):

Code :
  1. static void tronquer (char *verbe, char *verbe_tronque)
  2. {
  3. verbe[strlen (verbe) - 2] = '\0';
  5. strcpy (verbe_tronque, verbe);
  6. }


Enfin, un 'tronquage' ne nécessite pas de recopie. Tu peux donc simplifier comme ceci :

Code :
  1. static void tronquer (char *verbe)
  2. {
  3. verbe[strlen (verbe) - 2] = '\0';
  4. }


Il faudrait prendre cependant quelques précautions comme :

Code :
  1. static void tronquer (char *mot)
  2. {
  3.    if (mot != 0)
  4.    {
  5.       size_t const len = strlen (verbe);
  6.       if (len >= 2)
  7.       {
  8.          verbe[len - 2] = '\0';
  9.       }
  10.    }
  11. }


Je pense que si une phase de conception avait été réalisée, on aurait écrit le bon code directement...

 

D'ailleurs ça s'applique à l'ensemble du programme dont le codage me parait bien compliqué, malgré un main() prometteur, il faut le souligner... J'aimerais bien voir le document de conception...


Message édité par Emmanuel Delahaye le 26-11-2006 à 01:38:01

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 29-11-2006 à 22:46:38    

Je met en suspend ce sujet vu que je viens de tomber sur un cours qui explique les pointeurs de zéro (j'ai pas mal de difficultés avec). le temps de l'étudier et je reviens au travail précédent ;)

Reply

Sujets relatifs:

Leave a Replay

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