Comment convertir unsigned long en chaîne

En langage C, comment convertir une valeur longue non signée en chaîne ( char * ) tout en conservant mon code source portable ou tout simplement en le recompilant pour qu’il fonctionne sur une autre plate-forme (sans réécriture du code?).

Par exemple, si j’ai sprintf(buffer, format, value) , comment puis-je déterminer la taille du tampon de manière indépendante de la plate-forme?

 const int n = snprintf(NULL, 0, "%lu", ulong_value); assert(n > 0); char buf[n+1]; int c = snprintf(buf, n+1, "%lu", ulong_value); assert(buf[n] == '\0'); assert(c == n); 

L’approche standard consiste à utiliser sprintf(buffer, "%lu", value); écrire une chaîne représentant la value dans le buffer . Cependant, le débordement est un problème potentiel, car sprintf écrit volontiers (et à son insu) sur la fin de votre mémoire tampon.

C’est en fait une grosse faiblesse de sprintf, partiellement corrigée en C ++ en utilisant des stream plutôt que des tampons. La “réponse” habituelle consiste à allouer un tampon très généreux peu susceptible de déborder, laisser sprintf y afficher le résultat, puis utiliser strlen pour déterminer la longueur réelle de la chaîne produite, appeler un tampon de (taille + 1) et copier la chaîne dans celle-ci. .

Ce site traite longuement de cette question et des problèmes connexes.

Certaines bibliothèques proposent snprintf comme alternative, ce qui vous permet de spécifier une taille de tampon maximale.

vous pouvez écrire une fonction qui convertit de unsigned long en str, similaire à la fonction de bibliothèque ltostr.

 char *ultostr(unsigned long value, char *ptr, int base) { unsigned long t = 0, res = 0; unsigned long tmp = value; int count = 0; if (NULL == ptr) { return NULL; } if (tmp == 0) { count++; } while(tmp > 0) { tmp = tmp/base; count++; } ptr += count; *ptr = '\0'; do { res = value - base * (t = value / base); if (res < 10) { * -- ptr = '0' + res; } else if ((res >= 10) && (res < 16)) { * --ptr = 'A' - 10 + res; } } while ((value = t) != 0); return(ptr); } 

vous pouvez vous référer à mon blog ici qui explique la mise en œuvre et l'utilisation avec exemple.

 char buffer [50]; unsigned long a = 5; int n=sprintf (buffer, "%lu", a); 

Essayez d’utiliser sprintf :

 unsigned long x=1000000; char buffer[21]; sprintf(buffer,"%lu", x); 

Modifier:

Notez que vous devez allouer un tampon à l’avance et que vous n’aurez aucune idée de la longueur réelle des chiffres. Je suppose des long 32 bits, qui peuvent produire des nombres aussi grands que 10 chiffres.

Voir la réponse de Carl Smosortingcz pour une meilleure explication des problèmes en cause.

Pour une valeur longue, vous devez append les informations de longueur ‘l’ et ‘u’ pour l’entier décimal non signé,

comme référence des options disponibles, voir sprintf

 #include  int main () { unsigned long lval = 123; char buffer [50]; sprintf (buffer, "%lu" , lval ); }