Comment faire pour convertir un int en string en C?

EDIT: Comme souligné dans le commentaire, itoa() n'est pas un standard, afin de mieux utiliser sprintf() approche proposée dans l'rivalisant de réponse!

---

Vous pouvez utiliser itoa() fonction de convertir votre valeur entière à une chaîne.

Voici un exemple:

int num = 321;
char snum[5];

//convert 123 to string [buf]
itoa(num, snum, 10);

//print our string
printf("%s\n", snum);

---

Si vous voulez sortir de votre structure dans un fichier, il n'est pas nécessaire de convertir n'importe quelle valeur à l'avance. Vous pouvez simplement utiliser le une spécification de format de printf pour indiquer la façon de sortie de vos valeurs et de l'utiliser tous les opérateurs de printf famille pour la production de vos données.

La réponse courte est:

snprintf( str, size, "%d", x );

Le plus est: d'abord vous devez trouver une taille suffisante. snprintf vous indique la longueur si vous l'appelez, avec NULL, 0 comme première paramètres:

snprintf( NULL, 0, "%d", x );

Attribuer un caractère plus pour les nuls-terminator.

int x = -42;
int length = snprintf( NULL, 0, "%d", x );
char* str = malloc( length + 1 );
snprintf( str, length + 1, "%d", x );
...
free(str);

Si travaux pour chaque chaîne de format, de sorte que vous pouvez convertir en float ou double à la chaîne à l'aide de "%g", vous pouvez les convertir en int au sortilège de l'aide "%x", et ainsi de suite.

C'est vieux mais voici une autre façon.

#include <stdio.h>

#define atoa(x) #x

int main(int argc, char *argv[])
{
    char *string = atoa(1234567890);
    printf("%s\n", string);
    return 0;
}

La conversion à une chaîne, soit 1) affecte la chaîne résultante ou 2) passer dans un char * de destination et la taille. Exemple de code ci-dessous:

À la fois de travail pour tous les int y compris INT_MIN. Ils fournissent une qualité constante, contrairement à snprintf() qui dépend de la localisation en cours.

Méthode 1: Retourne NULL de mémoire.

#define INT_DECIMAL_STRING_SIZE(int_type) ((CHAR_BIT*sizeof(int_type)-1)*10/33+3)

char *int_to_string_alloc(int x) {
  int i = x;
  char buf[INT_DECIMAL_STRING_SIZE(int)];
  char *p = &buf[sizeof buf - 1];
  *p = '
#define INT_DECIMAL_STRING_SIZE(int_type) ((CHAR_BIT*sizeof(int_type)-1)*10/33+3)
char *int_to_string_alloc(int x) {
int i = x;
char buf[INT_DECIMAL_STRING_SIZE(int)];
char *p = &buf[sizeof buf - 1];
*p = '\0';
if (i >= 0) {
i = -i;
}
do {
p--;
*p = (char) ('0' - i % 10);
i /= 10;
} while (i);
if (x < 0) {
p--;
*p = '-';
}
size_t len = (size_t) (&buf[sizeof buf] - p);
char *s = malloc(len);
if (s) {
memcpy(s, p, len);
}
return s;
}
';
  if (i >= 0) {
    i = -i;
  }
  do {
    p--;
    *p = (char) ('0' - i % 10);
    i /= 10;
  } while (i);
  if (x < 0) {
    p--;
    *p = '-';
  }
  size_t len = (size_t) (&buf[sizeof buf] - p);
  char *s = malloc(len);
  if (s) {
    memcpy(s, p, len);
  }
  return s;
}

Méthode 2: Il renvoie NULL si le tampon est trop petit.

static char *int_to_string_helper(char *dest, size_t n, int x) {
  if (n == 0) {
    return NULL;
  }
  if (x <= -10) {
    dest = int_to_string_helper(dest, n - 1, x / 10);
    if (dest == NULL) return NULL;
  }
  *dest = (char) ('0' - x % 10);
  return dest + 1;
}

char *int_to_string(char *dest, size_t n, int x) {
  char *p = dest;
  if (n == 0) {
    return NULL;
  }
  n--;
  if (x < 0) {
    if (n == 0) return NULL;
    n--;
    *p++ = '-';
  } else {
    x = -x;
  }
  p = int_to_string_helper(p, n, x);
  if (p == NULL) return NULL;
  *p = 0;
  return dest;
}

[Modifier] demande par @Alter Mann

(CHAR_BIT*sizeof(int_type)-1)*10/33+3 est au moins le nombre maximum de char nécessaires pour coder les quelques signé de type entier comme une chaîne constituée d'un signe négatif, des chiffres, et un caractère nul..

Le nombre de non-signe bits d'un entier signé est pas plus de CHAR_BIT*sizeof(int_type)-1. Base 10 à la représentation d'un nbits du nombre binaire prend jusqu'à n*log10(2) + 1 chiffres. 10/33 est un peu plus de log10(2). +1 pour le signe char et +1 pour le caractère null. D'autres fractions peut être utilisé comme 28/93.

---

Méthode 3: Si on veut vivre sur le bord et de débordement de la mémoire tampon n'est pas une préoccupation, une simple C99 ou tard, la solution suivante qui gère tous int.

#include <limits.h>
#include <stdio.h>

static char *itoa_simple_helper(char *dest, int i) {
  if (i <= -10) {
    dest = itoa_simple_helper(dest, i/10);
  }
  *dest++ = '0' - i%10;
  return dest;
}

char *itoa_simple(char *dest, int i) {
  char *s = dest;
  if (i < 0) {
    *s++ = '-';
  } else {
    i = -i;
  }
  *itoa_simple_helper(s, i) = '
#include <limits.h>
#include <stdio.h>
static char *itoa_simple_helper(char *dest, int i) {
if (i <= -10) {
dest = itoa_simple_helper(dest, i/10);
}
*dest++ = '0' - i%10;
return dest;
}
char *itoa_simple(char *dest, int i) {
char *s = dest;
if (i < 0) {
*s++ = '-';
} else {
i = -i;
}
*itoa_simple_helper(s, i) = '\0';
return dest;
}
int main() {
char s[100];
puts(itoa_simple(s, 0));
puts(itoa_simple(s, 1));
puts(itoa_simple(s, -1));
puts(itoa_simple(s, 12345));
puts(itoa_simple(s, INT_MAX-1));
puts(itoa_simple(s, INT_MAX));
puts(itoa_simple(s, INT_MIN+1));
puts(itoa_simple(s, INT_MIN));
}
';
  return dest;
}

int main() {
  char s[100];
  puts(itoa_simple(s, 0));
  puts(itoa_simple(s, 1));
  puts(itoa_simple(s, -1));
  puts(itoa_simple(s, 12345));
  puts(itoa_simple(s, INT_MAX-1));
  puts(itoa_simple(s, INT_MAX));
  puts(itoa_simple(s, INT_MIN+1));
  puts(itoa_simple(s, INT_MIN));
}

Exemple de sortie

0
1
-1
12345
2147483646
2147483647
-2147483647
-2147483648

Si vous voulez sortir de votre structure dans un fichier, il n'est pas nécessaire de convertir n'importe quelle valeur à l'avance. Vous pouvez simplement utiliser le format de printf spécification pour indiquer la façon de sortie de vos valeurs et de l'utiliser tous les opérateurs de famille printf pour la production de vos données.