Wo ist die itoa-Funktion unter Linux?

itoa()ist eine sehr praktische Funktion, um eine Zahl in eine Zeichenfolge umzuwandeln. Linux scheint nicht zu haben itoa(), gibt es eine äquivalente Funktion oder muss ich verwenden sprintf(str, "%d", num)?

EDIT: Sorry, ich hätte daran denken sollen, dass diese Maschine entschieden nicht dem Standard entspricht, da verschiedene nicht standardmäßige libcImplementierungen für akademische Zwecke angeschlossen wurden ;-)

Wie itoa()in der Tat nicht standardmäßig, wie von mehreren hilfreichen Kommentatoren erwähnt, ist es am besten, sprintf(target_string,"%d",source_int)oder zu verwenden (noch besser, weil es vor Pufferüberläufen sicher ist) snprintf(target_string, size_of_target_string_in_bytes, "%d", source_int). Ich weiß, dass es nicht ganz so prägnant oder cool ist wie itoa(), aber zumindest kannst du einmal schreiben, überall laufen (tm) ;-)

Hier ist die alte (bearbeitete) Antwort

Sie geben zu Recht an, dass die Standardeinstellung gcc libcnicht itoa()wie bei mehreren anderen Plattformen enthalten ist, da sie technisch nicht Teil des Standards ist. Sehen Sie hier für ein wenig mehr Informationen. Beachten Sie, dass Sie müssen

#include <stdlib.h>

Natürlich wissen Sie bereits , dies, weil man wollte verwenden itoa() unter Linux nach vermutlich mit ihm auf einer anderen Plattform, aber ... der Code (gestohlen aus dem Link oben) würde wie folgt aussehen:

Beispiel

/* itoa example */
#include <stdio.h>
#include <stdlib.h>

int main ()
{
  int i;
  char buffer [33];
  printf ("Enter a number: ");
  scanf ("%d",&i);
  itoa (i,buffer,10);
  printf ("decimal: %s\n",buffer);
  itoa (i,buffer,16);
  printf ("hexadecimal: %s\n",buffer);
  itoa (i,buffer,2);
  printf ("binary: %s\n",buffer);
  return 0;
}

Ausgabe:

Enter a number: 1750
decimal: 1750
hexadecimal: 6d6
binary: 11011010110

Hoffe das hilft!

Wenn Sie es oft nennen, kann der Ratschlag "nur snprintf verwenden" ärgerlich sein. Also hier ist, was Sie wahrscheinlich wollen:

const char *my_itoa_buf(char *buf, size_t len, int num)
{
  static char loc_buf[sizeof(int) * CHAR_BITS]; /* not thread safe */

  if (!buf)
  {
    buf = loc_buf;
    len = sizeof(loc_buf);
  }

  if (snprintf(buf, len, "%d", num) == -1)
    return ""; /* or whatever */

  return buf;
}

const char *my_itoa(int num)
{ return my_itoa_buf(NULL, 0, num); }

itoaist keine Standard-C-Funktion. Sie können Ihre eigenen implementieren. Es erschien in der ersten Ausgabe von Kernighan und Ritchies The C Programming Language auf Seite 60. Die zweite Ausgabe von The C Programming Language ("K & R2") enthält die folgende Implementierung von itoaauf Seite 64. Das Buch stellt einige Probleme mit dieser Implementierung fest , einschließlich der Tatsache, dass die negativste Zahl nicht korrekt behandelt wird

 /* itoa:  convert n to characters in s */
 void itoa(int n, char s[])
 {
     int i, sign;

     if ((sign = n) < 0)  /* record sign */
         n = -n;          /* make n positive */
     i = 0;
     do {       /* generate digits in reverse order */
         s[i++] = n % 10 + '0';   /* get next digit */
     } while ((n /= 10) > 0);     /* delete it */
     if (sign < 0)
         s[i++] = '-';
     s[i] = '\0';
     reverse(s);
}  

Die reverseoben verwendete Funktion wurde zwei Seiten zuvor implementiert:

 #include <string.h>

 /* reverse:  reverse string s in place */
 void reverse(char s[])
 {
     int i, j;
     char c;

     for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
         c = s[i];
         s[i] = s[j];
         s[j] = c;
     }
}  

Bearbeiten: Ich habe gerade herausgefunden, std::to_stringwelche im Betrieb mit meiner eigenen Funktion unten identisch ist. Es wurde in C ++ 11 eingeführt und ist in neueren Versionen von gcc verfügbar, mindestens bereits ab 4.5, wenn Sie die c ++ 0x-Erweiterungen aktivieren.

std::string itos(int n)
{
   const int max_size = std::numeric_limits<int>::digits10 + 1 /*sign*/ + 1 /*0-terminator*/;
   char buffer[max_size] = {0};
   sprintf(buffer, "%d", n);
   return std::string(buffer);
}

Normalerweise wäre es sicherer, snprintfstatt zu verwenden, sprintfaber der Puffer ist sorgfältig dimensioniert, um immun gegen Überlaufen zu sein.

Siehe ein Beispiel: http://ideone.com/mKmZVE

Wie Matt J schrieb, gibt es itoa, aber es ist nicht Standard. Ihr Code ist portabler, wenn Sie ihn verwenden snprintf.

Die folgende Funktion reserviert gerade genug Speicher, um die Zeichenfolgendarstellung der angegebenen Zahl beizubehalten, und schreibt dann die Zeichenfolgendarstellung mit der Standardmethode in diesen Bereich sprintf.

char *itoa(long n)
{
    int len = n==0 ? 1 : floor(log10l(labs(n)))+1;
    if (n<0) len++; // room for negative sign '-'

    char    *buf = calloc(sizeof(char), len+1); // +1 for null
    snprintf(buf, len+1, "%ld", n);
    return   buf;
}

Vergessen Sie nicht, den freezugewiesenen Speicher zu erhöhen, wenn Sie ihn nicht benötigen:

char *num_str = itoa(123456789L);
// ... 
free(num_str);

NB Wenn snprintf n-1 Bytes kopiert, müssen wir snprintf (buf, len + 1, "% ld", n) aufrufen (nicht nur snprintf (buf, len, "% ld", n)).

Wo ist die itoa-Funktion unter Linux?

Unter Linux gibt es keine solche Funktion. Ich benutze stattdessen diesen Code.

/*
=============
itoa

Convert integer to string

PARAMS:
- value     A 64-bit number to convert
- str       Destination buffer; should be 66 characters long for radix2, 24 - radix8, 22 - radix10, 18 - radix16.
- radix     Radix must be in range -36 .. 36. Negative values used for signed numbers.
=============
*/

char* itoa (unsigned long long  value,  char str[],  int radix)
{
    char        buf [66];
    char*       dest = buf + sizeof(buf);
    boolean     sign = false;

    if (value == 0) {
        memcpy (str, "0", 2);
        return str;
    }

    if (radix < 0) {
        radix = -radix;
        if ( (long long) value < 0) {
            value = -value;
            sign = true;
        }
    }

    *--dest = '\0';

    switch (radix)
    {
    case 16:
        while (value) {
            * --dest = '0' + (value & 0xF);
            if (*dest > '9') *dest += 'A' - '9' - 1;
            value >>= 4;
        }
        break;
    case 10:
        while (value) {
            *--dest = '0' + (value % 10);
            value /= 10;
        }
        break;

    case 8:
        while (value) {
            *--dest = '0' + (value & 7);
            value >>= 3;
        }
        break;

    case 2:
        while (value) {
            *--dest = '0' + (value & 1);
            value >>= 1;
        }
        break;

    default:            // The slow version, but universal
        while (value) {
            *--dest = '0' + (value % radix);
            if (*dest > '9') *dest += 'A' - '9' - 1;
            value /= radix;
        }
        break;
    }

    if (sign) *--dest = '-';

    memcpy (str, dest, buf +sizeof(buf) - dest);
    return str;
}

Ich habe meine eigene Implementierung von itoa () ausprobiert. Es scheint in Binär, Oktal, Dezimal und Hex zu funktionieren

#define INT_LEN (10)
#define HEX_LEN (8)
#define BIN_LEN (32)
#define OCT_LEN (11)

static char *  my_itoa ( int value, char * str, int base )
{
    int i,n =2,tmp;
    char buf[BIN_LEN+1];


    switch(base)
    {
        case 16:
            for(i = 0;i<HEX_LEN;++i)
            {
                if(value/base>0)
                {
                    n++;
                }
            }
            snprintf(str, n, "%x" ,value);
            break;
        case 10:
            for(i = 0;i<INT_LEN;++i)
            {
                if(value/base>0)
                {
                    n++;
                }
            }
            snprintf(str, n, "%d" ,value);
            break;
        case 8:
            for(i = 0;i<OCT_LEN;++i)
            {
                if(value/base>0)
                {
                    n++;
                }
            }
            snprintf(str, n, "%o" ,value);
            break;
        case 2:
            for(i = 0,tmp = value;i<BIN_LEN;++i)
            {
                if(tmp/base>0)
                {
                    n++;
                }
                tmp/=base;
            }
            for(i = 1 ,tmp = value; i<n;++i)
            {
                if(tmp%2 != 0)
                {
                    buf[n-i-1] ='1';
                }
                else
                {
                    buf[n-i-1] ='0';
                }
                tmp/=base;
            }
            buf[n-1] = '\0';
            strcpy(str,buf);
            break;
        default:
            return NULL;
    }
    return str;
}

direkte Kopie in den Puffer: 64-Bit-Ganzzahl itoa hex:

    char* itoah(long num, char* s, int len)
    {
            long n, m = 16;
            int i = 16+2;
            int shift = 'a'- ('9'+1);


            if(!s || len < 1)
                    return 0;

            n = num < 0 ? -1 : 1;
            n = n * num;

            len = len > i ? i : len;
            i = len < i ? len : i;

            s[i-1] = 0;
            i--;

            if(!num)
            {
                    if(len < 2)
                            return &s[i];

                    s[i-1]='0';
                    return &s[i-1];
            }

            while(i && n)
            {
                    s[i-1] = n % m + '0';

                    if (s[i-1] > '9')
                            s[i-1] += shift ;

                    n = n/m;
                    i--;
            }

            if(num < 0)
            {
                    if(i)
                    {
                            s[i-1] = '-';
                            i--;
                    }
            }

            return &s[i];
    }

Hinweis: Ändern Sie für 32-Bit-Computer long in long long. long to int für 32-Bit-Ganzzahlen. m ist der Radix. Erhöhen Sie beim Verringern des Radix die Anzahl der Zeichen (Variable i). Verringern Sie beim Erhöhen des Radix die Anzahl der Zeichen (besser). Im Falle eines vorzeichenlosen Datentyps wird i nur 16 + 1.

Hier ist eine stark verbesserte Version von Archanas Lösung. Es funktioniert für alle Radix 1-16 und Zahlen <= 0 und sollte den Speicher nicht überladen.

static char _numberSystem[] = "0123456789ABCDEF";
static char _twosComp[] = "FEDCBA9876543210";

static void safestrrev(char *buffer, const int bufferSize, const int strlen)
{
    int len = strlen;
    if (len > bufferSize)
    {
        len = bufferSize;
    }
    for (int index = 0; index < (len / 2); index++)
    {
        char ch = buffer[index];
        buffer[index] = buffer[len - index - 1];
        buffer[len - index - 1] = ch;
    }
}

static int negateBuffer(char *buffer, const int bufferSize, const int strlen, const int radix)
{
    int len = strlen;
    if (len > bufferSize)
    {
        len = bufferSize;
    }
    if (radix == 10)
    {
        if (len < (bufferSize - 1))
        {
            buffer[len++] = '-';
            buffer[len] = '\0';
        }
    }
    else
    {
        int twosCompIndex = 0;
        for (int index = 0; index < len; index++)
        {
            if ((buffer[index] >= '0') && (buffer[index] <= '9'))
            {
                twosCompIndex = buffer[index] - '0';
            }
            else if ((buffer[index] >= 'A') && (buffer[index] <= 'F'))
            {
                twosCompIndex = buffer[index] - 'A' + 10;
            }
            else if ((buffer[index] >= 'a') && (buffer[index] <= 'f'))
            {
                twosCompIndex = buffer[index] - 'a' + 10;
            }
            twosCompIndex += (16 - radix);
            buffer[index] = _twosComp[twosCompIndex];
        }
        if (len < (bufferSize - 1))
        {
            buffer[len++] = _numberSystem[radix - 1];
            buffer[len] = 0;
        }
    }
    return len;
}

static int twosNegation(const int x, const int radix)
{
    int n = x;
    if (x < 0)
    {
        if (radix == 10)
        {
            n = -x;
        }
        else
        {
            n = ~x;
        }
    }
    return n;
}

static char *safeitoa(const int x, char *buffer, const int bufferSize, const int radix)
{
    int strlen = 0;
    int n = twosNegation(x, radix);
    int nuberSystemIndex = 0;

    if (radix <= 16)
    {
        do
        {
            if (strlen < (bufferSize - 1))
            {
                nuberSystemIndex = (n % radix);
                buffer[strlen++] = _numberSystem[nuberSystemIndex];
                buffer[strlen] = '\0';
                n = n / radix;
            }
            else
            {
                break;
            }
        } while (n != 0);
        if (x < 0)
        {
            strlen = negateBuffer(buffer, bufferSize, strlen, radix);
        }
        safestrrev(buffer, bufferSize, strlen);
        return buffer;
    }
    return NULL;
}

Wenn Sie sie nur drucken möchten:

void binary(unsigned int n)
{
    for(int shift=sizeof(int)*8-1;shift>=0;shift--)
    {
       if (n >> shift & 1)
         printf("1");
       else
         printf("0");

    }
    printf("\n");
} 

Wenn Sie den Code von Leuten lesen, die davon leben, werden Sie einen langen Weg finden.

Schauen Sie sich an, wie die Leute von MySQL das gemacht haben. Die Quelle ist SEHR GUT KOMMENTIERT und wird Ihnen viel mehr beibringen als gehackte Lösungen, die überall zu finden sind.

MySQLs Implementierung von int2str

Ich stelle hier die erwähnte Implementierung zur Verfügung; Der Link dient als Referenz und sollte zum Lesen der vollständigen Implementierung verwendet werden.

char *
int2str(long int val, char *dst, int radix, 
        int upcase)
{
  char buffer[65];
  char *p;
  long int new_val;
  char *dig_vec= upcase ? _dig_vec_upper : _dig_vec_lower;
  ulong uval= (ulong) val;

  if (radix < 0)
  {
    if (radix < -36 || radix > -2)
      return NullS;
    if (val < 0)
    {
      *dst++ = '-';
      /* Avoid integer overflow in (-val) for LLONG_MIN (BUG#31799). */
      uval = (ulong)0 - uval;
    }
    radix = -radix;
  }
  else if (radix > 36 || radix < 2)
    return NullS;

  /*
    The slightly contorted code which follows is due to the fact that
    few machines directly support unsigned long / and %.  Certainly
    the VAX C compiler generates a subroutine call.  In the interests
    of efficiency (hollow laugh) I let this happen for the first digit
    only; after that "val" will be in range so that signed integer
    division will do.  Sorry 'bout that.  CHECK THE CODE PRODUCED BY
    YOUR C COMPILER.  The first % and / should be unsigned, the second
    % and / signed, but C compilers tend to be extraordinarily
    sensitive to minor details of style.  This works on a VAX, that's
    all I claim for it.
  */
  p = &buffer[sizeof(buffer)-1];
  *p = '\0';
  new_val= uval / (ulong) radix;
  *--p = dig_vec[(uchar) (uval- (ulong) new_val*(ulong) radix)];
  val = new_val;
  while (val != 0)
  {
    ldiv_t res;
    res=ldiv(val,radix);
    *--p = dig_vec[res.rem];
    val= res.quot;
  }
  while ((*dst++ = *p++) != 0) ;
  return dst-1;
}

Wo ist die itoa-Funktion unter Linux?

Wie itoa()es in C nicht Standard ist, existieren verschiedene Versionen mit verschiedenen Funktionssignaturen.
char *itoa(int value, char *str, int base);ist in * nix üblich.

Sollte es unter Linux fehlen oder wenn Code die Portabilität nicht einschränken möchte, könnte Code es sich selbst machen.

Im Folgenden finden Sie eine Version, die keine Probleme mit INT_MINProblempuffern hat und diese behandelt: NULLoder eine unzureichende Pufferrückgabe NULL.

#include <stdlib.h>
#include <limits.h>
#include <string.h>

// Buffer sized for a decimal string of a `signed int`, 28/93 > log10(2)
#define SIGNED_PRINT_SIZE(object)  ((sizeof(object) * CHAR_BIT - 1)* 28 / 93 + 3)

char *itoa_x(int number, char *dest, size_t dest_size) {
  if (dest == NULL) {
    return NULL;
  }

  char buf[SIGNED_PRINT_SIZE(number)];
  char *p = &buf[sizeof buf - 1];

  // Work with negative absolute value
  int neg_num = number < 0 ? number : -number;

  // Form string
  *p = '\0';
  do {
    *--p = (char) ('0' - neg_num % 10);
    neg_num /= 10;
  } while (neg_num);
  if (number < 0) {
    *--p = '-';
  }

  // Copy string
  size_t src_size = (size_t) (&buf[sizeof buf] - p);
  if (src_size > dest_size) {
    // Not enough room
    return NULL;
  }
  return memcpy(dest, p, src_size);
}

Unten finden Sie eine C99 oder neuere Version, die jede Basis handhabt [2 ... 36]

char *itoa_x(int number, char *dest, size_t dest_size, int base) {
  if (dest == NULL || base < 2 || base > 36) {
    return NULL;
  }

  char buf[sizeof number * CHAR_BIT + 2]; // worst case: itoa(INT_MIN,,,2)
  char *p = &buf[sizeof buf - 1];

  // Work with negative absolute value to avoid UB of `abs(INT_MIN)`
  int neg_num = number < 0 ? number : -number;

  // Form string
  *p = '\0';
  do {
    *--p = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[-(neg_num % base)];
    neg_num /= base;
  } while (neg_num);
  if (number < 0) {
    *--p = '-';
  }

  // Copy string
  size_t src_size = (size_t) (&buf[sizeof buf] - p);
  if (src_size > dest_size) {
    // Not enough room
    return NULL;
  }
  return memcpy(dest, p, src_size);
}

Ersetzen Sie für einen C89- und weiter kompatiblen Code die innere Schleife durch

  div_t qr;
  do {
    qr = div(neg_num, base);
    *--p = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[-qr.rem];
    neg_num = qr.quot;
  } while (neg_num);

glibc interne Implementierung

glibc 2.28 hat eine interne Implementierung:

• stdio-common / _itoa.c
• sysdeps / generic / _itoa.h

das wird an mehreren Stellen intern verwendet, aber ich konnte nicht finden, ob es belichtet werden kann oder wie.

Zumindest sollte dies eine robuste Implementierung sein, wenn Sie bereit sind, sie zu extrahieren.

In dieser Frage wird gefragt, wie Sie Ihre eigenen rollen: Wie konvertiere ich ein int in einen String in C?

Ich würde dies vorziehen: https://github.com/wsq003/itoa_for_linux

Es sollte das schnellste itoa () aller Zeiten sein. Wir verwenden aus Leistungsgründen itoa () anstelle von sprintf (), daher ist ein schnellstes itoa () mit eingeschränkter Funktion sinnvoll und sinnvoll.

Ich habe _itoa (...) auf RedHat 6 und GCC Compiler verwendet. Es klappt.

Der Ersatz durch snprintf ist NICHT vollständig!

Es werden nur Basen abgedeckt: 2, 8, 10, 16, während itoa für Basen zwischen 2 und 36 funktioniert.

Da ich nach einem Ersatz für Base 32 gesucht habe, muss ich wohl meinen eigenen codieren!

Sie können dieses Programm anstelle von sprintf verwenden.

void itochar(int x, char *buffer, int radix);

int main()
{
    char buffer[10];
    itochar(725, buffer, 10);
    printf ("\n %s \n", buffer);
    return 0;
}

void itochar(int x, char *buffer, int radix)
{
    int i = 0 , n,s;
    n = s;
    while (n > 0)
    {
        s = n%radix;
        n = n/radix;
        buffer[i++] = '0' + s;
    }
    buffer[i] = '\0';
    strrev(buffer);
}