Comment convertir Un int en chaîne de caractères en C?

comment convertir un int (entier) en chaîne de caractères? Je suis en train de faire une fonction qui convertit les données d'un struct dans une chaîne à enregistrer dans un fichier.

131

11 réponses

EDIT: Comme l'a 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 la fonction itoa() pour convertir votre valeur entière en 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 votre structure dans un fichier il n'est pas nécessaire de convertir une valeur à l'avance. Vous pouvez simplement utiliser le spécification de format printf pour indiquer comment afficher vos valeurs et utiliser l'un des opérateurs de famille printf pour afficher vos données.

56
répondu Alexander Galkin 2011-11-24 13:34:42

Vous pouvez utiliser sprintf de le faire, ou peut-être snprintf si vous l'avez:

char str[ENOUGH];
sprintf(str, "%d", 42);

où le nombre de caractères (plus le caractère final) dans le str peut être calculé en utilisant:

(int)((ceil(log10(num))+1)*sizeof(char))
128
répondu cnicutar 2013-06-23 19:30:51

la réponse courte est:

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

le plus long est: d'abord vous devez trouver la 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 de plus à null-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 fonctionne pour chaque chaîne de format, de sorte que vous pouvez convertir flottant ou double en chaîne en utilisant "%g" , vous pouvez convertir int en hex en utilisant "%x" , et ainsi de suite.

32
répondu user2622016 2015-09-28 09:39:07

après avoir examiné les différentes versions de itoa pour gcc, la version la plus flexible que j'ai trouvé qui est capable de gérer les conversions en binaire, décimal et hexadécimal, à la fois positif et négatif est la quatrième version trouvée à http://www.strudel.org.uk/itoa / . Alors que sprintf / snprintf ont des avantages, ils ne manipuleront pas les nombres négatifs pour autre chose que la conversion décimale. Depuis le lien ci-dessus est soit hors ligne ou plus actif, J'ai inclus leur 4ème version ci-dessous:

char *
itoa (int value, char *result, int base)
{
    // check that the base if valid
    if (base < 2 || base > 36) { *result = '"151900920"'; 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-- = '"151900920"';
    while (ptr1 < ptr) {
        tmp_char = *ptr;
        *ptr--= *ptr1;
        *ptr1++ = tmp_char;
    }
    return result;
}
22
répondu David C. Rankin 2014-05-24 02:16:54

c'est vieux, mais il y a un autre moyen.

#include <stdio.h>

#define atoa(x) #x

int main(int argc, char *argv[])
{
    char *string = atoa(1234567890);
    printf("%s\n", string);
    return 0;
}
8
répondu catfood 2014-05-24 02:26:38

si vous utilisez GCC, vous pouvez utiliser la fonction GNU extension asprintf.

char* str;
asprintf (&str, "%i", 12313);
free(str);
6
répondu Vicente Adolfo Bolea Sánchez 2015-09-22 19:51:33

convertir n'importe quoi en chaîne devrait soit 1) attribuer la chaîne résultante ou 2) passer dans une char * destination et la taille. Exemple de code ci-dessous:

tous les deux travaillent pour tous int y compris INT_MIN . Ils fournissent une sortie cohérente contrairement à snprintf() qui dépend de la localisation actuelle.

Méthode 1: Retourne NULL de la 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 = '"151900920"';
  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 retourne NULL si le tampon était 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écessaire pour encoder le type entier signé comme une chaîne de caractères comprenant un signe négatif optionnel, des chiffres, et un caractère nul..

le nombre de bits non-signalisés dans un entier signé n'est pas supérieur à CHAR_BIT*sizeof(int_type)-1 . Une base-10 représentation d'un n - nombre binaire de bits prend jusqu'à n*log10(2) + 1 chiffres. 10/33 est un peu plus que log10(2) . +1 pour le signe char et +1 pour le caractère null. D'autres fractions pourraient être utilisées comme 28/93.


Méthode 3: Si l'on veut vivre sur le bord et le débordement de tampon n'est pas un problème, une solution C99 simple ou ultérieure suit qui manipule tout" 1519370920 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) = '"151920920"';
  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));
}

Production de l'échantillon

0
1
-1
12345
2147483646
2147483647
-2147483647
-2147483648
6
répondu chux 2017-03-03 17:25:45
/*Function return size of string and convert signed  *
 *integer to ascii value and store them in array of  *
 *character with NULL at the end of the array        */

int itoa(int value,char *ptr)
     {
        int count=0,temp;
        if(ptr==NULL)
            return 0;   
        if(value==0)
        {   
            *ptr='0';
            return 1;
        }

        if(value<0)
        {
            value*=(-1);    
            *ptr++='-';
            count++;
        }
        for(temp=value;temp>0;temp/=10,ptr++);
        *ptr='"151900920"';
        for(temp=value;temp>0;temp/=10)
        {
            *--ptr=temp%10+'0';
            count++;
        }
        return count;
     }
3
répondu kannadasan 2016-08-27 20:56:55

si vous voulez sortir votre structure dans un fichier, il n'est pas nécessaire de convertir une valeur à l'avance. Vous pouvez simplement utiliser la spécification de format printf pour indiquer comment afficher vos valeurs et utiliser l'un des opérateurs de la famille printf pour afficher vos données.

2
répondu user2374601 2013-05-12 09:46:40

INT TO CHAR [exemple de code complet ]

#include <stdio.h>
int main()
    {
    char s[]="";
    sprintf(s,"%d",368);
    printf("%s",s);
}

et il n'est pas nécessaire de déclarer la taille du vecteur s [] .. cool hun?! :- )

NOTE: ne pas démarrer le valeur int avec "0 "

"
0
répondu PYK 2018-08-08 19:14:18

utilisez la fonction itoa() pour convertir un entier en chaîne de caractères

par exemple:

char msg[30];
int num = 10;
itoa(num,msg,10);
0
répondu Codemaker 2018-10-06 08:05:37