🚀 go-pugleaf

Alain CROS wrote:
> Bonjour.

Bonjour,

>
> 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);
> ou bien je peux me contenter d'écrire
>     memcpy(ch, c, taille);

sizeof(char) == 1 par définition, donc seconde forme pour moi. Ceci
dit, si tu dois un jour copier avec memcpy() des données d'un autre
type, utiliser sizeof(type)*taille est une bonne pratique, notamment
avec les tableaux. Pour ne pas se tromper, utiliser l'opérateur sizeof
sur la donnée elle-même (de type bien défini) plutôt que de passer
un type n'est pas mal non plus. Je privilégie le premier cas si je
travaille avec des tableaux, le second si je travaille avec des
pointeurs, pas bien dur de voir le pourquoi. Si je travaille avec le
type char, pointeur ou tableau, je ne précise que la taille.

exple :
#define SIZE_ARR 50
double arr1[SIZE_ARR];
double arr2[SIZE_ARR];
double * pData1;
double * pData2;
/* ... */
/* with arrays */
memcpy(arr2, arr1, sizeof(double)*SIZE_ARR);
/* with pointers */
memcpy(pData2, pData1, sizeof(*pData1)*SIZE_ARR);


> Toutes critiques sur la fonction seront les bienvenues.
>
> Merci.
>
> Alain CROS
>
> #include <string.h>
>
> 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];

Attention, C99 ;-).

>     char *pch = ch;
>     memcpy(ch, c, sizeof(char) * taille);

      /* Copie chaine source */
      memcpy(ch, c, taille);

>     ch[taille] = '\0';
>     while(*pch != '\0')
>     {
>         if((*pch < '0') || (*pch > '9'))

           /* Inclure ctype.h et profiter des fonctions de
classification */
           if (!isdigit(*pch)) {

>             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);

      return j; /* tout court*/

> }

Note : plus d'accolades avec les if ne ferait pas de mal. Je pense
aussi que tu as un pointeur en trop (pch) : tupeux très bien
sauvegarder la chaine à traiter, travailler directement dessus, puis
la restaurer en cas de besoin.

Ma version serait quelquechose du genre :

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

int isCharValid(char c)
{
    return ( (isdigit(c) || c == '.' || c == ',') ? 1 : 0 );
}

/**
 * comma2dot
 * Remplace la virgule par le point comme séparateur dans une chaine
numérique
 * @param[in] s chaine à traiter
 * @return rc
 *  0 : succes
 *  -1 : argument nul
 *  -2 : pb allocation
 *  -3 : chaine fournie non valide
 */
int comma2dot(char * s)
{
    int rc = 0;

    if (s != NULL) {

        size_t lg = strlen(s);
        char * tmp = malloc(lg+1);

        if (tmp != NULL) {

            int cptDot = 0;
            memcpy(tmp, s, lg+1);

            /* boucle de traitement */
            /* on remplace toutes les virgules rencontrées par des
points */
            /* on se préoccuppera plus tard de la validité de la
chaine */
            /* avec le nb de points insérés */
            while(*s != '\0') {
                if (isCharValid(*s)) {
                    if (*s == '.') { ++cptDot; }
                    if (*s == ',') { *s = '.'; ++cptDot; }
                }
                else {
                    rc = -3;
                    break;
                }
                ++s;
            }

            /* plus de 1 separateur rencontres, ca va pas */
            rc = (cptDot > 1) ? -3 : rc;

            /* restauration de la chaine initiale si pas bon */
            if (rc == -3)  {
                memcpy(s, tmp, lg+1);
            }

            free(tmp);

        }
        else { rc = -2; }
    }
    else { rc = -1; }

    return rc;

}

A+
Regis