Recherche algo de la fonction ulltoa() [Résolu]

akboy7015 8 Messages postés samedi 21 août 2004Date d'inscription 8 septembre 2004 Dernière intervention - 2 sept. 2004 à 13:05 - Dernière réponse : akboy7015 8 Messages postés samedi 21 août 2004Date d'inscription 8 septembre 2004 Dernière intervention
- 8 sept. 2004 à 22:25
Actuellement, je développe sur VC7 et je travail beaucoup avec des __int64. Le problème est que la fonction ulltoa() n'a pas l'air d'exister.

Bien entendu, je ne cherche pas a utiliser sprintf car ce que je cherche avant tout c'est l'algorithme de cette fonction pour savoir comment ça fonctionne...

Si quelqu'un pourrai me donner l'algo de cette fonction pour que je puisse l'étudier, ce serai sympa. (si c'est en assembleur, c'est encore mieux)

merci d'avance :)
Afficher la suite 

Votre réponse

4 réponses

Meilleure réponse
cs_aardman 1905 Messages postés mercredi 22 janvier 2003Date d'inscription 17 septembre 2012 Dernière intervention - 2 sept. 2004 à 20:05
3
Merci
Salut,
Pour convertir les __int64 tu as _i64toa() et pour les unsigned __int64 tu as _ui64toa().

Merci cs_aardman 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 97 internautes ce mois-ci

Commenter la réponse de cs_aardman
cs_djl 3011 Messages postés jeudi 26 septembre 2002Date d'inscription 27 novembre 2004 Dernière intervention - 2 sept. 2004 à 13:52
0
Merci
tu peux partir du itoa de k&r


void itoa(int n, char s[])
{
int i, sign;

if((sign = n ) < 0)	/* record sign */
n=-n;		/* make n >0   */
i=0;
do {		/*generate digits in reverse order */
s[i++] = n % 10 + '0';	/* get next digit */
} while ((n /= 10) > 0);		/* delete it */
if (sign < 0 )
s[i++] = '-';
s[i] = '\0';
reverse(s);
}

void reverse(char s[])
{
int c,i,j;
for(i=0,j=strlen(s)-1; i < j; i++,j--) {
c=s[i];
s[i]=s[j];
s[j]=c;
}
}

Commenter la réponse de cs_djl
Hades53 231 Messages postés mercredi 12 février 2003Date d'inscription 7 juillet 2009 Dernière intervention - 2 sept. 2004 à 13:56
0
Merci
La fonction de BruNews pourra t-être utile:
__declspec(naked) char* __fastcall bnultoa(unsigned int dwnum, char* szdst) 
{ 
  __asm {
    or       ecx, ecx
    jnz      short L1
    lea      eax, [edx+1]
    mov      byte ptr[edx], 48
    mov      byte ptr[eax], cl
    ret      0
 L1:
    mov      [esp-4], edi
    mov      [esp-8], edx
    mov      edi, edx
 L2:
    mov      eax, -858993459
    mul      ecx
    mov      eax, edx
    shr      eax, 3
    mov      edx, ecx
    lea      ecx, [eax+eax*8]
    add      ecx, eax
    sub      edx, ecx
    add      dl, 48
    mov      [edi], dl
    mov      ecx, eax
    inc      edi
    test     eax, eax
    jnz      short L2
    mov      byte ptr[edi], al
    mov      [esp-12], edi
    mov      eax, [esp-8]
 L3:
    dec      edi
    mov      dl, [eax]
    mov      cl, [edi]
    mov      [edi], dl
    mov      [eax], cl
    inc      eax
    cmp      eax, edi
    jb       short L3
    mov      eax, [esp-12]
    mov      edi, [esp-4]
    ret      0
  }
}
Commenter la réponse de Hades53
akboy7015 8 Messages postés samedi 21 août 2004Date d'inscription 8 septembre 2004 Dernière intervention - 8 sept. 2004 à 22:25
0
Merci
Merci aardman!

Hades53> J'avais deja trouvé ce code dans plusieur sources mais merci tout de meme
Commenter la réponse de akboy7015

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.