Gdzie jest funkcja itoa w systemie Linux?

itoa()to bardzo przydatna funkcja do konwersji liczby na łańcuch. Wydaje się itoa(), że Linux nie ma , czy istnieje równoważna funkcja, czy muszę jej użyć sprintf(str, "%d", num)?

EDYCJA: Przepraszam, powinienem był pamiętać, że ta maszyna jest zdecydowanie niestandardowa, po podłączeniu różnych niestandardowych libcimplementacji do celów naukowych ;-)

Ponieważ itoa()jest to rzeczywiście niestandardowe, o czym wspomniało kilku pomocnych komentatorów, najlepiej jest użyć sprintf(target_string,"%d",source_int)lub (jeszcze lepiej, ponieważ jest bezpieczny przed przepełnieniem bufora) snprintf(target_string, size_of_target_string_in_bytes, "%d", source_int). Wiem, że to nie jest tak zwięzłe ani fajne, jak itoa(), ale przynajmniej możesz napisać raz, biegać wszędzie (tm) ;-)

Oto stara (zredagowana) odpowiedź

Masz rację twierdząc, że domyślna gcc libcwersja nie obejmuje itoa(), jak kilka innych platform, ponieważ technicznie nie jest częścią standardu. Zobacz tutaj, aby uzyskać więcej informacji. Pamiętaj, że musisz

#include <stdlib.h>

Oczywiście już to wiesz, ponieważ chciałeś używać itoa() na Linuksie po przypuszczalnym użyciu go na innej platformie, ale ... kod (skradziony z powyższego linku) wyglądałby tak:

Przykład

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

Wynik:

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

Mam nadzieję że to pomoże!

Jeśli często to nazywasz, porada „po prostu użyj snprintf” może być denerwująca. Oto, czego prawdopodobnie chcesz:

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

itoanie jest standardową funkcją C. Możesz wdrożyć własne. Pojawił się w pierwszym wydaniu języka programowania C Kernighana i Ritchiego , na stronie 60. Drugie wydanie języka programowania C („K & R2”) zawiera następującą implementację , na stronie 64. Książka zwraca uwagę na kilka kwestii związanych z tą implementacją , w tym fakt, że nie obsługuje poprawnie większości liczb ujemnychitoa

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

Funkcja reverseużyta powyżej została zaimplementowana dwie strony wcześniej:

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

Edycja: właśnie dowiedziałem się, std::to_stringktóra jest identyczna w działaniu jak moja własna funkcja poniżej. Został wprowadzony w C ++ 11 i jest dostępny w najnowszych wersjach gcc, przynajmniej od 4.5, jeśli włączysz rozszerzenia c ++ 0x.

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

Zwykle byłoby bezpieczniejsze w użyciu snprintfzamiast, sprintfale bufor jest starannie dobrany, aby był odporny na przepełnienie.

Zobacz przykład: http://ideone.com/mKmZVE

Jak napisał Matt J, jest itoa, ale to nie jest standard. Twój kod będzie bardziej przenośny, jeśli użyjesz snprintf.

Następująca funkcja przydziela wystarczającą ilość pamięci, aby zachować ciąg reprezentujący podaną liczbę, a następnie zapisuje reprezentację ciągu w tym obszarze przy użyciu standardowej sprintfmetody.

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

Nie zapomnij o freezwiększeniu przydzielonej pamięci, gdy jej nie potrzebujesz:

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

NB Ponieważ snprintf kopiuje n-1 bajtów, musimy wywołać snprintf (buf, len + 1, "% ld", n) (nie tylko snprintf (buf, len, "% ld", n))

Gdzie jest funkcja itoa w systemie Linux?

W Linuksie nie ma takiej funkcji. Zamiast tego używam tego kodu.

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

Wypróbowałem własną implementację itoa (), wygląda na to, że działa w systemie binarnym, ósemkowym, dziesiętnym i szesnastkowym

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

bezpośrednia kopia do bufora: 64-bitowa liczba całkowita 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];
    }

Uwaga: zmień długi na długi długi dla maszyny 32-bitowej. long to int w przypadku 32-bitowej liczby całkowitej. m jest podstawą. Zmniejszając podstawę, zwiększ liczbę znaków (zmienna i). Zwiększając podstawę, zmniejsz liczbę znaków (lepiej). W przypadku typu danych bez znaku, i staje się po prostu 16 + 1.

Oto znacznie ulepszona wersja rozwiązania Archana. Działa dla każdej podstawy od 1 do 16 i liczb <= 0 i nie powinien obciążać pamięci.

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

Jeśli chcesz je tylko wydrukować:

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

Czytanie kodu facetów, którzy zajmują się tym na życie, da ci DŁUGIE SPOSOBY.

Sprawdź, jak zrobili to faceci z MySQL. Źródło jest BARDZO DOBRZE KOMENTARZE i nauczy Cię znacznie więcej niż zhakowanych rozwiązań znalezionych w każdym miejscu.

Implementacja MySQL int2str

Podaję tutaj wspomnianą implementację; link jest tutaj w celach informacyjnych i powinien być używany do czytania pełnej implementacji.

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

Gdzie jest funkcja itoa w systemie Linux?

Ponieważ itoa()nie jest to standardem w C, istnieją różne wersje z różnymi podpisami funkcji.
char *itoa(int value, char *str, int base);jest powszechne w * nix.

Jeśli brakuje go w Linuksie lub jeśli kod nie chce ograniczać przenośności, kod może uczynić go własnym.

Poniżej znajduje się wersja, która nie ma problemów z problemami z INT_MINbuforami i nie obsługuje buforów: NULLlub zwraca niewystarczający bufor 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);
}

Poniżej znajduje się wersja C99 lub nowsza, która obsługuje dowolną podstawę [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);
}

W przypadku kodu zgodnego ze standardem C89 i nowszym zamień pętlę wewnętrzną na

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

Wewnętrzna implementacja glibc

glibc 2.28 ma wewnętrzną implementację:

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

który jest używany wewnętrznie w kilku miejscach, ale nie mogłem znaleźć, czy można go odsłonić ani jak.

Przynajmniej powinna to być solidna implementacja, jeśli chcesz ją wyodrębnić.

To pytanie dotyczy tego, jak rzucić własne: Jak przekonwertować int na string w C?

Wolałbym to: https://github.com/wsq003/itoa_for_linux

Powinna to być najszybsza itoa () w historii. Używamy itoa () zamiast sprintf () ze względu na wydajność, więc najszybsza itoa () z ograniczonymi funkcjami jest rozsądna i warta zachodu.

Użyłem _itoa (...) na RedHacie 6 i kompilatorze GCC. To działa.

Zamiana za pomocą snprintf NIE jest zakończona!

Obejmuje tylko bazy: 2, 8, 10, 16, podczas gdy itoa działa dla podstaw od 2 do 36.

Ponieważ szukałem zamiennika bazy 32, myślę, że będę musiał zakodować własną!

Możesz użyć tego programu zamiast sprintf.

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