Convertir en int en char "à la main"

Version imprimable

19/03/2014, 17h05
Jérôme .G

Convertir en int en char "à la main"

Bonjour à tous,

J'aurais besoin de convertir un signed long en tableau de caractères, mais sans aucune bibliothèque car je travaille sur de l'embarqué.

Merci d'avance !
19/03/2014, 17h14
Metalman

my_itoa :

- trouver le signe (+ ou -)
- récupérer l'ordre de grandeur en base 10 de la valeur absolue (cpt = 0; tant que nombre > 0 faire un div 10 et cpt++)
- allouer le nombre de cases + 1 (+1 si négatif) pour des char
- faire des modulos, s'aligner sur le code ASCII de '0', écrire la valeur dans la case correspondante du tableau
- ne pas oublier le '\0' à la fin...

Et voili voilou !
19/03/2014, 17h26
fred1599

1 minute de recherche et ... voilà !
20/03/2014, 07h34
Jérôme .G

Merci beaucoup pour ces réponses et la rapidité !

Il ne me reste plus qu'à essayer tout ça.

Malheureusement je n'arrive pas à utiliser la fonction.. Peut être que je ne l'appelle pas bien.

J'ai un booléen qui m'indique que je rentre bien dans mon traitement 'TraitemensCommandes' mais après plus rien (la LED témoin de ma carte électronique s'arrête de clignoter donc plantage du programme) et bien sûr pas de point d'arrêt pour voir ce qui se déroule dans la fonction itoa.

Ma fonction légèrement modifiée (value est un signed long et non plus un int) :

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
char * itoa_c ( signed long  value, char * result, int base )
{                                                                                                                                                        
    // check that the base if valid                                                                                                                      
    if ( base < 2 || base > 36 ) {                                                                                                                       
         *result = '\0';                                                                                                                                  
         return result;                                                                                                                                   
    }                                                                                                                                                    
 
    char* ptr = result, *ptr1 = result, tmp_char;                                                                                                        
    int tmp_value;                                                                                                                                       
 
    do {                                                                                                                                                 
         tmp_value = value;                                                                                                                               
         value /= base;                                                                                                                                   
         *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + (tmp_value - value * base)];                             
    } while ( value );                                                                                                                                   
 
    // Apply negative sign                                                                                                                               
    if ( tmp_value < 0 )                                                                                                                                 
         *ptr++ = '-';                                                                                                                                    
         *ptr-- = '\0';                                                                                                                                       
 
    while ( ptr1 < ptr ) {                                                                                                                               
         tmp_char = *ptr;                                                                                                                                 
         *ptr-- = *ptr1;                                                                                                                                  
         *ptr1++ = tmp_char;                                                                                                                              
    }                                                                                                                                                    
 
    return result;                                                                                                                                       
}

L'appel :

Code:

1
2
3
4
5
6
7
8
void TraitementCommandes ()
 {  
 	if (( cSerialCmd [0] == 'S' )&&( cSerialCmd [1] == 'T' ))	
	{	
                // Je suis sûr de passer la condition ci-dessus
		cX = itoa_c( slX, cX, 10 );
	}
 }

slX contient à ce moment le nombre 50.
cX est déclaré après les #include dans le .c :

Code:

char * cX;

Merci d'avance.

Citation:

cX est déclaré après les #include dans le .c :

Code:

char * cX;

:aie:

Code:

1
2
3
4
5
6
7
8
char* ptr = result, *ptr1 = result, tmp_char;                                                                                                        
    int tmp_value;                                                                                                                                       
 
    do {                                                                                                                                                 
         tmp_value = value;                                                                                                                               
         value /= base;                                                                                                                                   
         *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + (tmp_value - value * base)];                             
    } while ( value );

Ce code fait quoi? ptr vaut quoi? si ptr est juste déclaré en tant que char * sans initialisation?

20/03/2014, 13h27
Jérôme .G

Ce code vient du lien que fred1599 a posté au dessus.

Je suppose qu'il est bon.
20/03/2014, 13h53
mith06

OK

Arrêtons tous de réfléchir alors.
20/03/2014, 14h21
Jérôme .G

ptr prend la valeur de result, grâce à cette ligne:

char* ptr = result;

ptr est donc initialisé, ce qui explique ma réponse évasive à ta question, "Ce code fait quoi? ptr vaut quoi? si ptr est juste déclarer en tant que char * sans initialisation?", peu constructive à mon sens.

Je voulais juste savoir si j'utilisais correctement la fonction qu'on m'avait gentiment proposé.
20/03/2014, 15h09
mith06

char* ptr = result = cX qui lui n'est pas initialisé.
20/03/2014, 15h14
Jérôme .G

D'accord, mais il y a quelque chose que je ne comprend pas : cX contiendra le résultat de la fonction, avant il n'a pas de valeur, pourquoi et comment dois-je l'initialiser ?

Merci.
20/03/2014, 15h21
gangsoleil

Bonjour,

Lorsque tu ecris char * cX;, tu definis un pointeur sur un char. La valeur pointée est "n'importe quoi". Donc la premiere chose que tu fais, c'est *ptr++ = ..., c'est a dire que tu ecris nulle part.

Il faut que tu alloues la zone memoire dans laquelle tu vas ecrire avec malloc (ou calloc).
20/03/2014, 15h24
mith06

Soit un malloc, soit tu le déclare directement cX comme un tableau de char.
Mais dans tous les cas il te faut savoir quelle taille tu veux pour ce tableau.
20/03/2014, 15h28
gangsoleil

Citation:

Envoyé par Jérôme .G

Je suppose qu'il est bon.

Tout ton probleme est la : on te donne gentiement un lien, et tu l'appliques sans chercher a le comprendre ni a le verifier, et encore moins a comprendre comment il faut l'utiliser.

La premiere chose qui me choque dans ce code, c'est la declaration des variables au milieu du code.
La seconde, c'est la non verification que "result" n'est pas NULL. Or comme tu fais ptr=result, puis *ptr++, si result est NULL, tu vas avoir des surprises.
Et puis cette ligne *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + (tmp_value - value * base)]; ....
20/03/2014, 15h37
Jérôme .G

Comprendre ce code et comprendre comment l'utiliser est tout ce que je demande.

J'ai testé le code vu que ça ne marchait pas, et posté mon code pour savoir si je l'utilisais bien.

Si j'ai demandé de l'aide c'est parce que je ne suis pas capable de produire ce code moi-même, difficile alors d'avoir un regard critique.

Maintenant que j'en sais en plus sur les pointeurs je pense pouvoir avancer.

Merci pour vos réponses.
20/03/2014, 16h43
gangsoleil

Bonjour,

Je pense que n'importe quel moteur de recherche avec "code source itoa" t'aurait donne une solution. Quoi qu'il en soit, ce n'est pas parce qu'un code est sur le net qu'il est bon -- ni qu'il est mauvais d'ailleurs.

Avant de l'utiliser, essaie de comprendre le code, et de voir ce qu'il fait -- notamment la ligne *ptr++
21/03/2014, 11h27
fred1599

Citation:

Il faut que tu alloues la zone memoire dans laquelle tu vas ecrire avec malloc (ou calloc).

Tout est dit, d'ailleurs j'ai testé il est fonctionnel, sans fuite... Bref il est nickel !

En donnant ce lien, je voulais surtout affirmer qu'une recherche rapide suffisait...

Citation:

La seconde, c'est la non verification que "result" n'est pas NULL. Or comme tu fais ptr=result, puis *ptr++, si result est NULL, tu vas avoir des surprises.

Peut-être a-t-il considéré que cette vérification était faite au préalable (on peut limite en être sûr sinon en effet c'est une erreur)

Citation:

La premiere chose qui me choque dans ce code, c'est la declaration des variables au milieu du code.

Arf, malheureusement ça ne me surprend plus :roll:

Cette fonction n'aurait-elle pas un air de ressemblance avec strcpy par exemple ? :mrgreen: