convertir nombre entier non signé 32 bits (optimisation)

Version imprimable

Bonjour,

Je voudrais convertir un string en nombre entier non signé codé sur 32 bits.

J'ai donc créé ces fonctions

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
typedef enum _BOOL{
    FALSE = 0,
    TRUE = 1
} BOOL;
typedef int INT32;
typedef unsigned int UINT32;
typedef unsigned long long UINT64;
 
 
/**
 * @brief powUINT64(x, y) = x ^ y.
 * Fait un calcul d'un nombre à la puissance d'un autre.
 */
UINT64 powUINT64(UINT64 x, UINT64 y){
    UINT64 i;
    UINT64 val = 1;
 
    for (i=0; i < y; i++){
        val *= x;
    }
    return val;
}
 
 
/**
 * @brief Converti un string en UINT32 (base 10).
 * La chaine ne doit pas contenir d'espace sinon ça retourne une erreur.
 *
 * @return retourne TRUE si conversion réussite.
 */
BOOL convStrtoUINT32(char *str, int len, UINT32 *retVal){
    // valeur max d'un UINT32 = 4 294 967 295
    UINT64 val = 0;
    int index = 0;
 
    printf("convStrtoUINT32->str \"%s\", len %i\r\n", str, len); // debug
 
    if(len < 1){
        return FALSE;
    }
 
    if(len > 10){
        return FALSE;
    }
 
    while(len--){
        char valTmp = str[len];
 
        if((valTmp < '0') || (valTmp > '9')){
            return FALSE;
        }
 
        //printf("valTmp : %u, 10^%i=%llu => %llu\r\n", valTmp - '0', index, powUINT64(10, index), (valTmp - '0') * powUINT64(10, index)); // debug
        val += (valTmp - '0') * powUINT64(10, index);
        index++;
    }
 
    if(val > 0xFFFFFFFF){
      return FALSE;
    }
 
    *retVal = val;
    return TRUE;
}

Je voudrais que ça me retourne des erreurs si :
- il y a des espaces dans la chaine
- la chaine est erronée
- il y a un dépassement de taille

J'aimerai que le code soit optimisé pour un µControlleur 32 bits

Je ne vois pas qu'elle est la meilleurs solution à adopter (surtout pour la détection de dépassement de taille)
=> il faut que je passe sur des variables de 64 bits pendant le calcul ?

Merci d'avance,

Quelque chose du genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <ctype.h>
BOOL convStrtoUINT32(char *str, int len, UINT32 *retVal)
{
  char * p = str+len-1;
  UINT32 pwr = 1;
  UINT32 val = 0;
  if(len <1 || len > 10) return FALSE;
  while(p != str)
  {
    if(!isdigit(*p)) return FALSE;
    val += (*p-'0')*pwr;
    pwr *= 10;
    p--;
  }
  if(!isdigit(*p) || (val > 294967295 && (*p-'0')==4)
    ||( len == 10 && (*p-'0') >4 )) return FALSE;
  *retVal = val + (*p-'0')*pwr;
  return TRUE;
}

07/06/2012, 14h14
boboss123

merci, mais cette fonction ne gère pas les dépassements (ex : "9123456789" ne renvoie pas d'erreur)
=> c'est pour ça que je pensais passer sur des variables de 64 bits mais je voulais savoir s'il n'y avait pas une methode plus efficace vu que mon CPU n'est que 32bits.

Pour faire une conversion en décimale, il n'y a pas des algo plus optimisés (c'est super lourd toutes ces additions/multiplications) ?
=> peut être que je devrais plutôt aller sur le forum algorithme ?
07/06/2012, 17h29
gangsoleil

Citation:

Envoyé par boboss123

merci, mais cette fonction ne gère pas les dépassements (ex : "9123456789" ne renvoie pas d'erreur)

Outre le test de la longueur de la chaine (qui est deja present dans le code propose), tu peux utiliser strcmp : tu compares ta chaine a ULONG_MAX sous forme de chaine (a savoir 4294967295) : si le resultat de strcmp est positif, tu as un debordement de capacite.

(*) Pour le test de la longueur de la chaine, ca peut etre une mauvaise optimisation : si ta chaine est le plus souvent de longueur strictement inferieure a 10, alors le test est interessant car tu evites une comparaison de chaine systematique.
En revanche, si la longueur de ta chaine est majoritairement 10, alors le test est absolument inutile, et ne fait que rajouter des instructions.

Sinon, Est-ce que tu as essaye de regarder quel etait le code de strtol ? Car sauf erreur de ma part, c'est bien la foncition que tu essayes de recoder (mais qui n'est pas presente sur ton microcontrolleur a priori).
07/06/2012, 17h49
diogene
Citation:

merci, mais cette fonction ne gère pas les dépassements

Oui, il y a une erreur dans le test :oops:
Je pense que celui-ci serait mieux
Code:

1 2 if( !isdigit(*p) || (val > 294967295 && (*p-'0')==4) ||( len == 10 && (*p-'0') >4 )) return FALSE;
(Je corrige mon post précédent)

Salut,

J'ai trouvé une solution artillerie lourde - C99 only, à cause de l'usage de unsigned long long int... Mais dans la fonction de conversion seulement. Il n'y a aucune raison que ça ne marche pas sur un 32 bits. En fait, on applique la formule value = value * 10 + digit et on teste si on déborde sur les 33-41èmes bits. Comme on est sûr de bien gérer le débordement, on n'a plus à passer la taille max en paramètre.

A+

Pfeuh

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include <ctype.h>
#include <assert.h>
 
typedef unsigned int UINT32;
typedef unsigned long long int UINT64;
 
#define CVRT_ERR_NO_ERROR     0
#define CVRT_ERR_OVERFLOW     1
#define CVRT_ERR_NOT_A_DIGIT  2
#define CVRT_ERR_EMPTY_STRING 3
 
int str2uint32(char *str, UINT32 *value)
{
    UINT64 temp_value = 0;
 
    if(*str == '\0')
        return CVRT_ERR_EMPTY_STRING;
    while(1)
    {
        if(*str == '\0')
        {
            /* The string has been successfully parsed */
            *value = temp_value;
            return CVRT_ERR_NO_ERROR;
        }
        if(!isdigit(*str))
            return CVRT_ERR_NOT_A_DIGIT;
        /* add the digit */
        temp_value = temp_value * 10 + (*str - '0');
        /* ultimate test with nthe new value */
        if((temp_value & 0xF00000000ll) != 0)
            return CVRT_ERR_OVERFLOW;
        str++;
    }
}
 
int main(void)
{
    UINT32 result;
    int diag;
 
    assert(sizeof(UINT32) == 4);
    assert(sizeof(UINT64) == 8);
 
    result = 0; /* if an error occurs result should NOT be modified */
    diag = str2uint32("123b0", &result);
    assert(diag == CVRT_ERR_NOT_A_DIGIT);
    assert(result == 0);
 
    diag = str2uint32("", &result);
    assert(diag == CVRT_ERR_EMPTY_STRING);
    assert(result == 0);
 
    diag = str2uint32("00000004294967295", &result); /* biggest regular value */
    assert(diag == CVRT_ERR_NO_ERROR);
    assert(result == 0xffffffff);
 
    result = 0; /* if an error occurs result should NOT be modified */
    diag = str2uint32("00000004294967296", &result); /* first overflow value */
    assert(diag == CVRT_ERR_OVERFLOW);
    assert(result == 0);
 
    result = 0; /* if an error occurs result should NOT be modified */
    diag = str2uint32("000000042949672950", &result); /* 10 times biggest to be sure */
    assert(diag == CVRT_ERR_OVERFLOW);
    assert(result == 0);
 
    result = 0; /* if an error occurs result should NOT be modified */
    diag = str2uint32("0000000429496729500", &result); /* 100 times biggest to be sure */
    assert(diag == CVRT_ERR_OVERFLOW);
    assert(result == 0);
 
    return 0;
}

08/06/2012, 13h42
boboss123

ok merci pour les infos