it-swarm.com.de

Wie konvertiere ich ein int in einen String in C?

Wie konvertiert man eine int (Ganzzahl) in eine Zeichenfolge? Ich versuche eine Funktion zu erstellen, die die Daten einer struct in eine Zeichenfolge konvertiert, um sie in einer Datei zu speichern.

145
user1063999

EDIT: Wie im Kommentar erwähnt, ist itoa() kein Standard. Verwenden Sie daher den in der rivalisierenden Antwort vorgeschlagenen Ansatz sprintf ()!


Sie können itoa() function verwenden, um konvertieren Ihren ganzzahligen Wert in einen String umzuwandeln.

Hier ist ein Beispiel:

int num = 321;
char snum[5];

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

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

Wenn Sie Ihre Struktur in eine Datei ausgeben möchten, müssen Sie zuvor keinen Wert konvertieren. Sie können einfach die Spezifikation des printf-Formats verwenden, um anzugeben, wie Sie Ihre Werte ausgeben und einen der Operatoren der printf-Familie verwenden, um Ihre Daten auszugeben.

62

Sie können sprintf verwenden, oder snprintf, wenn Sie es haben:

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

Wobei die Anzahl der Zeichen (zuzüglich abschließender Zeichen) in der str berechnet werden kann mit:

(int)((ceil(log10(num))+1)*sizeof(char))
137
cnicutar

Die kurze Antwort lautet:

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

Je länger ist: Zuerst müssen Sie eine ausreichende Größe ermitteln. snprintf gibt die Länge an, wenn Sie es mit NULL, 0 als ersten Parametern aufrufen:

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

Ordnen Sie ein weiteres Zeichen für den Nullterminator zu.

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

Wenn dies für jeden Formatstring gilt, können Sie mithilfe von "%g" Float oder Double in String konvertieren. Mit "%x" können Sie int in Hex konvertieren.

38
user2622016

Nachdem ich verschiedene Versionen von itoa für gcc betrachtet habe, ist die flexibelste Version, die ich gefunden habe, die Konvertierungen in Binär-, Dezimal- und Hexadezimalwerte handhaben kann. Sowohl die positive als auch die negative Version ist die vierte Version, die unter http: //www.strudel zu finden ist .org.uk/itoa/ . sprintf/snprintf hat zwar Vorteile, behandelt negative Zahlen jedoch nur für die Dezimalkonvertierung. Da der obige Link entweder offline ist oder nicht mehr aktiv ist, habe ich die vierte Version hier eingefügt:

char *
itoa (int value, char *result, int base)
{
    // check that the base if valid
    if (base < 2 || base > 36) { *result = '\0'; 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-- = '\0';
    while (ptr1 < ptr) {
        tmp_char = *ptr;
        *ptr--= *ptr1;
        *ptr1++ = tmp_char;
    }
    return result;
}
26
David C. Rankin

Das ist alt, aber hier ist ein anderer Weg.

#include <stdio.h>

#define atoa(x) #x

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

Wenn Sie GCC verwenden, können Sie die asprintf-Funktion der Erweiterung GNU verwenden.

char* str;
asprintf (&str, "%i", 12313);
free(str);

Wenn Sie etwas in eine Zeichenfolge konvertieren, müssen Sie entweder 1) die resultierende Zeichenfolge zuweisen oder 2) ein char *-Ziel und eine Größe übergeben. Beispielcode unten:

Beide funktionieren für alle int einschließlich INT_MIN. Sie bieten eine konsistente Ausgabe im Gegensatz zu snprintf(), die vom aktuellen Gebietsschema abhängt.

Methode 1: Gibt NULL für nicht genügend Arbeitsspeicher zurück.

#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;
}

Methode 2: Es gibt NULL zurück, wenn der Puffer zu klein war.

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;
}

[Bearbeiten] als Anfrage von @Alter Mann

(CHAR_BIT*sizeof(int_type)-1)*10/33+3 ist mindestens die maximale Anzahl von char, die erforderlich ist, um den vorzeichenbehafteten Integer-Typ als eine Zeichenfolge zu codieren, die aus einem optionalen negativen Vorzeichen, Ziffern und einem Nullzeichen besteht. 

Die Anzahl der Nicht-Vorzeichenbits in einer vorzeichenbehafteten Ganzzahl beträgt nicht mehr als CHAR_BIT*sizeof(int_type)-1. Eine Basis-10-Darstellung einer n-Bit-Binärzahl nimmt bis zu n*log10(2) + 1-Ziffern an. 10/33 ist etwas mehr als log10(2). +1 für das Zeichen char und +1 für das Nullzeichen. Andere Fraktionen könnten wie 28/93 verwendet werden.


Methode 3: Wenn Sie auf dem Edge leben möchten und der Pufferüberlauf kein Problem darstellt, folgt eine einfache C99- oder spätere Lösung, die all int behandelt.

#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));
}

Beispielausgabe

0
1
-1
12345
2147483646
2147483647
-2147483647
-2147483648
6
chux
/*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='\0';
        for(temp=value;temp>0;temp/=10)
        {
            *--ptr=temp%10+'0';
            count++;
        }
        return count;
     }
3
kannadasan

Wenn Sie Ihre Struktur in eine Datei ausgeben möchten, müssen Sie zuvor keinen Wert konvertieren. Sie können einfach die Angabe des Printf-Formats verwenden, um anzugeben, wie Sie Ihre Werte ausgeben und einen Operator aus der Printf-Familie zur Ausgabe Ihrer Daten verwenden.

2
user2374601

verwenden Sie die Funktion itoa (), um eine Ganzzahl in eine Zeichenfolge zu konvertieren

Zum Beispiel:

char msg[30];
int num = 10;
itoa(num,msg,10);
0
Codemaker