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.
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.
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))
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.
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;
}
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;
}
si vous utilisez GCC, vous pouvez utiliser la fonction GNU extension asprintf.
char* str;
asprintf (&str, "%i", 12313);
free(str);
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
/*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;
}
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.
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 "
"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);