🚀 go-pugleaf

Alain CROS wrote on 23/09/05 :
> J'ai �crit une fonction qui remplace la virgule par un point dans une chaine 
> de caract�res pour ensuite permettre de faire un calcul.
> Pour copier une chaine dans une autre chaine, j'utilise memcpy.
> Est ce n�cessaire d'�crire
>     memcpy(ch, c, sizeof(char) * taille);

Redondance inutile. Par contre

     memcpy(ch, c, sizeof *ch * taille);

si le type est appel� � changer (char -> wchar_t, par exemple) et que 
la taille est un nombre d'�l�ments...

> ou bien je peux me contenter d'�crire
>     memcpy(ch, c, taille);

Oui, ou mieux

memcpy(ch, c, sizeof ch);

si ch est un tableau. Evidemment, si c'est un pointeur, il vaut mieux 
oublier (pas dangereux, mais s�rieusement limit�...)

> #include <string.h>
>
> int convstrnum(int taille, char *c)

La chaine initiale est donc modifiable. Je recommande size_t pour la 
taille. Si 'c' est l'adresse d'une chaine conforme, � quoi sert la 
taille ?

> /*  Remplace, dans une chaine de caract�res repr�sentant un chiffre,
>         la virgule par un point.
>     Retourne :
>         la position de ce point dans la chaine (base 1).
>         0 si pas de point.
>         -1 si pas un chiffre (la chaine reste inchang�e).
> */
> {
>     int i = 1, j = 0, k = 0;

Je recommande size_t pour i.

>     char ch[taille + 1];

[C99] VLA ? Je ne connais pas d'impl�mentation conforme. Qu'est-ce qui 
ne va pas avec malloc() ?

>     char *pch = ch;
>     memcpy(ch, c, sizeof(char) * taille);
>     ch[taille] = '\0';

S�curit� ?

>     while(*pch != '\0')
>     {
>         if((*pch < '0') || (*pch > '9'))
>             switch(*pch)
>             {
>                 case '.':
>                     j = (++k == 2) ? -1 : j;
>                     break;
>                 case ',':
>                     *pch-- = '.';
>                     j = i--;
>                     break;
>                 default:
>                     j = -1;
>             }
>         if(j == -1)
>             break;
>         *pch++;
>         i++;
>     }
>     if(j != -1)
>         memcpy(c, ch, sizeof(char) * taille);
>     return(j);
> }

Ca me parait hyper compliqu�! Si la chaine initiale est modifiable, il 
suffit de la modifier directement.

#include <string.h>
#include <stdio.h>
#include <ctype.h>

/* 0 | 1 */
#define ED 0

#if !ED
static int convstrnum (int taille, char *c)
/*  Remplace, dans une chaine de caract�res repr�sentant un chiffre,
   la virgule par un point.
   Retourne :
   la position de ce point dans la chaine (base 1).
   0 si pas de point.
   -1 si pas un chiffre (la chaine reste inchang�e).
 */
{
   int i = 1, j = 0, k = 0;
   char ch[taille + 1];
   char *pch = ch;
   memcpy (ch, c, sizeof (char) * taille);
   ch[taille] = '\0';
   while (*pch != '\0')
   {
      if ((*pch < '0') || (*pch > '9'))
         switch (*pch)
         {
         case '.':
            j = (++k == 2) ? -1 : j;
            break;
         case ',':
            *pch-- = '.';
            j = i--;
            break;
         default:
            j = -1;
         }
      if (j == -1)
         break;
      *pch++;
      i++;
   }
   if (j != -1)
      memcpy (c, ch, sizeof (char) * taille);
   return (j);
}
#else
/*  Remplace, dans une chaine de caract�res repr�sentant un nombre,
   la virgule par un point.
   Retourne :
   la position de ce point dans la chaine (base 1).
   0 si pas de point.
   -1 si pas un nombre (la chaine reste inchang�e).
 */
static int convstrnum (char *c)
{
   int n = -1;
   char *p = c;

   while (*p != 0)
   {
      if (n == -1)
      {
         if (isdigit (*p) || *p == '-')
         {
            n = 0;
         }
         else
         {
            break;
         }
      }
      else
      {
         if (*p == ',')
         {
            *p = '.';
            n = (int) (p - c) + 1;
         }
      }

      p++;
   }
   return n;
}
#endif

int main (void)
{
   char as[][32] =
   {
      "",
      "abc",
      "123",
      "-123",
      "123,456",
      "-123,456",
   };
   size_t i;

   for (i = 0; i < sizeof as / sizeof *as; i++)
   {
      char *s = as[i];
      printf ("'%s' -> ", s);
      {
#if !ED
         int n = convstrnum ((int) strlen (s), s);
#else
         int n = convstrnum (s);
#endif
         printf ("'%s' (%d)\n", s, n);
      }
   }
   return 0;
}

-- 
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

.sig under repair