Discussion :

[chester12]

Bonsoir tout le monde !!
J'aimerais écrire une fonction qui permet de mettre un nombre réel double dans une chaine de caractères et une fonction qui fait l'inverse.
Est ce que quelqu'un a une idée?

[Invité]

Bonsoir,

Pourquoi écrire une fonction qui existe déjà ? (sauf pour son intérêt perso, mais là il faudrait montrer le code que tu as déjà fait).

Voir la FAQ
Chaîne->nombre
Nombre->chaîne

[mith06]

Salut j'ai un fonction qui transforme une chaine en un float, donc facilement transposable vers le double.

Header:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdbool.h>
#include <stdint.h>
/*-----------------------------------------------------------------------------------------------*/
/*===============================================================================================*/
/**
 *\return true if c is the space (' ') character
 */
static inline bool is_space(char c){
    return (bool)c == ' ';
}/* end is_space*/
/*-----------------------------------------------------------------------------------------------*/
/*===============================================================================================*/
/**
 * return true if char c belongs to ['0' '1' '2' '3' '4' '5' '6' '7' '8' '9']
 */
static inline bool isdecdigit(char c){
    return c >= '0' && c <= '9';
}/* end isdecdigit*/
/*-----------------------------------------------------------------------------------------------*/
/*===============================================================================================*/
/**
 *\brief convert caracter c (witch must be a decimal digit) into an integer
 */
static inline uint32_t ctoi(char c){
    return (uint32_t)c - (uint32_t)'0';
}/* end ctoi*/

le source C:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
/*-----------------------------------------------------------------------------------------------*/
/*===============================================================================================*/
/**
 *\brief return the conversion of string str into an float
 */
float str2f(const char * str, char **endptr)
{
    const char * p = str;
    float float_value = 0.0f;
    if(p)
    {   /* clear first space characters*/
        while(is_space(*p)){p++;}
        /* check if negative or positive*/
        bool negative = false;
        if(*p == '-')
        {
            negative = true;
            p++;
        }
        else if(*p == '+')
        {
            p++;
        }
        /*convert decimal floor part */
        uint32_t floor = 0;
        /* convert char to decimal*/
        while(isdecdigit(*p))
        {
            floor = floor*10 + ctoi(*p);
            p++;
        }/* end while(isdecdigit(*p))*/
        /* float convertion of floor part*/
        float_value = (float)floor;
        /*Process decimal part*/
 
        if(*p == '.')
        {   /* there is a decimal part*/
            float decimal = 0.0f;
            float decimal_exponent = 1.0f;
            p++;
            while (isdecdigit(*p))
            {
                decimal = decimal * 10.0f +  (float)ctoi(*p);
                decimal_exponent  *= 10.0f;
                p++;
 
            }/* end while(isdecdigit(*p))*/
            /* float convertion of decimal part*/
            if(decimal_exponent > 1.0f)
            {
                float_value += decimal/decimal_exponent;
            }
        }/* end if (*p == '.')*/
 
        /* set the sign of mantissa*/
        if(negative){float_value = -float_value;}
 
        /* Process an exponent string*/
        if (*p == 'e' || *p == 'E')
        {   /* there is an exponent*/
            int32_t exponent = 0;
            /* Handle optional sign*/
            p++;
            negative = false;
            if(*p == '-')
            {
                negative = true;
                p++;
            }
            else if(*p == '+')
            {
                p++;
            }
 
            /* Process string exponent behind e or E*/
            while (isdecdigit(*p))
            {
                exponent = exponent * 10 + ctoi(*p);
                p++;
            }
            float real_exponant = 1.0f;
            int32_t i;
 
            if(negative)
            {   /* negative exponent => div */
                for(i = 0 ; i < exponent ; i++)
                {
                    real_exponant /= 10.f;/* exponent is base10*/
                }
            }
            else
            {   /* positive exponent => mul */
                for(i = 0 ; i < exponent ; i++)
                {
                    real_exponant *= 10.f;/* exponent is base10*/
                }
            }
            /* update the float value*/
            float_value *= real_exponant;
        }/* end if (*p == 'e' || *p == 'E')*/
    }/* end if(str)*/
    /* update pointer to end of conversion*/
    if(endptr){*endptr = (char *)p;}
    /* return the float_value conversion*/
    return float_value;
}/* end str2f*/

Par contre pour la la conversion des flottants vers une chaine j'utilise snprintf et ses dérivées...

PS : Les mecs qui ont écrit snprintf avec le support des nombres flottant, de leur précision du format, du padding etc sont des TUEURS...

[Bousk]

Bonjour,

dans un exercice similaire, réaliser la conversion string->float, la solution que l'on avait mise en place a été:

- déclarer un entier pow
- déclarer le float de retour fRet, initialisé à +0
- cas particulier du 1° caractère : est-ce qu'on a un - + ou aucun (+ par défaut) ?
> mise à jour du signe de fRet
- pour chaque caractère
- tant qu'on a rencontré aucun . (partie entière)
-- lire le caractère
--- si le caractère est le .
> initialiser pow à 0.1
--- sinon
> fRet = fRet * 10 + caractère lu
- si le . a déjà été rencontré (partie décimale)
-- lire le caractère
> fRet = fRet + caractère lu * pow
> pow *= 0.1 (on passe à la décimale suivante)

(de mémoire, et ça marchait bien, tant que la chaîne ne contenait que le float^^)

[Thierry Chappuis]

La bibliothèque standard définit des fonctions pour cela. strtod() et sprintf() voir snprintf(). Le but de ton exercices est probablement de réimplanter ta propre fonction, mais bon... poste un morceau de code et une description de ce qui te pose problème dans l'implantation d'une version basique de ces fonctions.

Avec mes meilleures salutations

Thierry