Wie kann ich in C einen Int in einen String umwandeln?

Wie konvertiert man ein int (Ganzzahl) in eine Zeichenfolge?

Ich versuche, eine Funktion zu erstellen, die die Daten von a konvertiert struct in eine Zeichenfolge, um sie in einer Datei zu speichern.

Sie können verwenden sprintf zu tun, oder vielleicht snprintf Wenn du es hast:

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

Wo die Anzahl der Zeichen (plus abschließendes Zeichen) in der str kann berechnet werden mit:

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

Wie in einem Kommentar erwähnt, itoa() ist kein Standard, verwenden Sie also besser den in der konkurrierenden Antwort vorgeschlagenen sprintf () -Ansatz!

Du kannst den … benutzen itoa() Funktion zu Konvertieren Ihren ganzzahligen Wert in eine Zeichenfolge.

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, brauchen Sie vorher keinen Wert umzuwandeln. Sie können einfach die verwenden printf-Formatspezifikation um anzugeben, wie Sie Ihre Werte ausgeben und einen der Operatoren von verwenden printf-Familie um Ihre Daten auszugeben.

Die kurze Antwort lautet:

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

Je länger ist: zuerst müssen Sie die ausreichende Größe herausfinden. snprintf sagt dir Länge wenn du es mit nennst NULL, 0 als erste Parameter:

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

Ordnen Sie dem Nullterminator ein Zeichen mehr zu.

#include <stdio.h> 
#include <stdlib.h>

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

Wenn das für jeden Format-String funktioniert, können Sie Float oder Double in einen String umwandeln, indem Sie verwenden "%g"können Sie mit int in hex umwandeln "%x"usw.

Nachdem ich mir verschiedene Versionen von itoa für gcc angesehen habe, ist die flexibelste Version, die ich gefunden habe und die in der Lage ist, Konvertierungen in Binär-, Dezimal- und Hexadezimalzahlen, sowohl positiv als auch negativ, zu handhaben, die vierte Version, die unter gefunden wird http://www.strudel.org.uk/itoa/. Während sprintf/snprintf haben Vorteile, sie verarbeiten keine negativen Zahlen für etwas anderes als die Dezimalumwandlung. Da der obige Link entweder offline oder nicht mehr aktiv ist, habe ich ihre 4. Version unten eingefügt:

/**
 * C++ version 0.4 char* style "itoa":
 * Written by Lukás Chmela
 * Released under GPLv3.
 */
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;
}

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

Das Konvertieren von irgendetwas in einen String sollte entweder 1) den resultierenden String zuweisen oder 2) in a übergeben char * Reiseziel und Größe. Beispielcode unten:

Beides funktioniert für alle int einschließlich INT_MIN. Sie bieten eine konsistente Ausgabe im Gegensatz zu snprintf() was vom aktuellen Gebietsschema abhängt.

Methode 1: Retouren NULL auf Speichermangel.

#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 kehrt zurück NULL 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;
}

[Edit] als Anfrage von @Alter Mann

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

Die Anzahl der Bits ohne Vorzeichen in einer vorzeichenbehafteten Ganzzahl ist nicht größer als CHAR_BIT*sizeof(int_type)-1. Eine Basis-10-Darstellung von a n-Bit Binärzahl dauert bis zu n*log10(2) + 1 Ziffern. 10/33 ist etwas mehr als log10(2). +1 für das Zeichen char und +1 für das Nullzeichen. Andere Brüche könnten verwendet werden, wie 28/93.

Methode 3: Wenn man am Rand leben möchte und Pufferüberlauf kein Problem darstellt, folgt eine einfache C99- oder neuere Lösung, die behandelt alle 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) = '\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

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

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