Hoe converteer je een int naar een string in C?

Hoe converteer je een int (geheel getal) naar een string? Ik probeer een functie te maken die de gegevens van een struct omzet in een tekenreeks om deze in een bestand op te slaan.


Antwoord 1, autoriteit 100%

EDIT: Zoals aangegeven in de opmerking, is itoa() geen standaard, dus gebruik de sprintf()-aanpak die wordt voorgesteld in het rivaliserende antwoord!


U kunt de functie itoa() gebruiken om uw gehele getal converteren naar een tekenreeks.

Hier is een voorbeeld:

int num = 321;
char snum[5];
// convert 123 to string [buf]
itoa(num, snum, 10);
// print our string
printf("%s\n", snum);

Als u uw structuur in een bestand wilt uitvoeren, hoeft u vooraf geen waarde te converteren. U kunt gewoon de printf-formaatspecificatie gebruiken om aan te geven hoe u uw waarden en gebruik een van de operators uit de printf-familie om uw gegevens uit te voeren.


Antwoord 2, autoriteit 212%

Je kunt sprintf gebruiken om het te doen, of misschien snprintf als je het hebt:

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

Waarbij het aantal tekens (plus afsluitend teken) in de str kan worden berekend met:

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

Antwoord 3, autoriteit 82%

Het korte antwoord is:

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

Hoe langer is: eerst moet je voldoende maat weten. snprintf vertelt je de lengte als je het aanroept met NULL, 0 als eerste parameters:

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

Wijs één teken meer toe voor null-terminator.

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

Als het werkt voor elke tekenreeks, zodat je float of double naar string kunt converteren met "%g", kun je int converteren naar hex met "%x", enzovoort.


Antwoord 4, autoriteit 24%

Na verschillende versies van itoa voor gcc te hebben bekeken, de meest flexibele versie die ik heb gevonden die in staat is om conversies naar binair, decimaal en hexadecimaal te verwerken, zowel positief als negatief, is de vierde versie gevonden op http://www.strudel.org.uk/itoa/. Hoewel sprintf/snprintf voordelen hebben, zullen ze geen negatieve getallen verwerken voor iets anders dan decimale conversie. Aangezien de bovenstaande link offline of niet langer actief is, heb ik hun 4e versie hieronder toegevoegd:

/**
 * C++ version 0.4 char* style "itoa":
 * Written by Lukas 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;
}

Antwoord 5, autoriteit 8%

Dit is oud, maar hier is een andere manier.

#include <stdio.h>
#define atoa(x) #x
int main(int argc, char *argv[])
{
    char *string = atoa(1234567890);
    printf("%s\n", string);
    return 0;
}

Antwoord 6, autoriteit 6%

Als u GCC gebruikt, kunt u de functie GNU-extensie asprintf gebruiken.

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

Antwoord 7, autoriteit 5%

Als je iets naar een tekenreeks converteert, moet ofwel 1) de resulterende tekenreeks worden toegewezen of 2) een char *-bestemming en -grootte invoeren. Voorbeeldcode hieronder:

Beide werken voor alle int inclusief INT_MIN. Ze bieden een consistente uitvoer in tegenstelling tot snprintf() die afhangt van de huidige landinstelling.

Methode 1: Retourneert NULL bij onvoldoende geheugen.

#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: Het geeft NULL terug als de buffer te klein was.

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

[Bewerken] op verzoek van @Alter Mann

(CHAR_BIT*sizeof(int_type)-1)*10/33+3 is ten minste het maximale aantal char dat nodig is om het een of ander ondertekend geheel getal te coderen als een tekenreeks bestaande uit een optioneel minteken, cijfers en een null-teken..

Het aantal niet-tekenbits in een geheel getal met teken is niet meer dan CHAR_BIT*sizeof(int_type)-1. Een basis-10-representatie van een n-bit binair getal duurt maximaal n*log10(2) + 1 cijfers. 10/33 is iets meer dan log10(2). +1 voor het teken char en +1 voor het null-teken. Andere breuken kunnen worden gebruikt zoals 28/93.


Methode 3: Als men aan de rand wil leven en bufferoverloop geen probleem is, volgt een eenvoudige C99 of latere oplossing die alle int afhandelt.

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

Voorbeelduitvoer

0
1
-1
12345
2147483646
2147483647
-2147483647
-2147483648

Antwoord 8, autoriteit 2%

Als u uw structuur in een bestand wilt uitvoeren, hoeft u vooraf geen waarde te converteren. U kunt gewoon de printf-formaatspecificatie gebruiken om aan te geven hoe u uw waarden moet uitvoeren en een van de operators uit de printf-familie gebruiken om uw gegevens uit te voeren.


Antwoord 9, autoriteit 2%

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

Antwoord 10

Gebruik functie itoa() om een ​​geheel getal om te zetten in een tekenreeks

Bijvoorbeeld:

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes