Chức năng itoa trong Linux ở đâu?

itoa()là một chức năng thực sự tiện dụng để chuyển đổi một số thành một chuỗi. Linux dường như không có itoa(), có chức năng tương đương hay tôi phải sử dụng sprintf(str, "%d", num)?

EDIT: Xin lỗi, tôi nên nhớ rằng máy này được quyết định là không chuẩn, đã cắm vào các libctriển khai phi tiêu chuẩn khác nhau cho mục đích học tập ;-)

Như itoa()thực sự là không chuẩn, như được đề cập bởi một số bình luận hữu ích, tốt nhất nên sử dụng sprintf(target_string,"%d",source_int)hoặc (tốt hơn nữa, vì nó an toàn từ tràn bộ đệm) snprintf(target_string, size_of_target_string_in_bytes, "%d", source_int). Tôi biết nó không hoàn toàn ngắn gọn hay thú vị như itoa(), nhưng ít nhất bạn có thể Viết một lần, Chạy mọi nơi (tm) ;-)

Đây là câu trả lời cũ (đã được chỉnh sửa)

Bạn đã đúng khi tuyên bố rằng mặc định gcc libckhông bao gồm itoa(), giống như một số nền tảng khác, do về mặt kỹ thuật nó không phải là một phần của tiêu chuẩn. Xem ở đây để biết thêm một chút. Lưu ý rằng bạn phải

#include <stdlib.h>

Tất nhiên bạn đã biết điều này, vì bạn muốn sử dụng itoa() trên Linux sau khi sử dụng nó trên nền tảng khác, nhưng ... mã (bị đánh cắp từ liên kết ở trên) sẽ trông như sau:

Thí dụ

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

Đầu ra:

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

Hi vọng điêu nay co ich!

Nếu bạn đang gọi nó rất nhiều, lời khuyên "chỉ cần sử dụng snprintf" có thể gây phiền nhiễu. Vì vậy, đây là những gì bạn có thể muốn:

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

itoakhông phải là một hàm C tiêu chuẩn. Bạn có thể thực hiện của riêng bạn. Nó xuất hiện trong phiên bản đầu tiên của Ngôn ngữ lập trình C của Kernighan và Ritchie , trên trang 60. Phiên bản thứ hai của Ngôn ngữ lập trình C ("K & R2") chứa cách triển khai sau , trên trang 64. Cuốn sách lưu ý một số vấn đề với việc triển khai này , bao gồm cả việc nó không xử lý chính xác số âm nhấtitoa

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

Các chức năng reverseđược sử dụng ở trên được thực hiện hai trang trước đó:

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

Chỉnh sửa: Tôi vừa tìm hiểu vềstd::to_string cái nào giống hệt với hoạt động của chính tôi dưới đây. Nó được giới thiệu trong C ++ 11 và có sẵn trong các phiên bản gần đây của gcc, ít nhất là sớm nhất là 4,5 nếu bạn kích hoạt các phần mở rộng 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);
}

Thông thường sẽ an toàn hơn khi sử dụng snprintfthay vìsprintf nhưng bộ đệm có kích thước cẩn thận để tránh bị tràn ngập.

Xem một ví dụ: http://ideone.com/mKmZVE

Như Matt J đã viết, có itoa, nhưng nó không chuẩn. Mã của bạn sẽ dễ mang theo hơn nếu bạn sử dụng snprintf.

Hàm sau phân bổ bộ nhớ vừa đủ để giữ biểu diễn chuỗi của số đã cho và sau đó ghi biểu diễn chuỗi vào vùng này bằng sprintfphương thức chuẩn .

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

Đừng quên freetăng bộ nhớ được phân bổ khi hết nhu cầu:

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

NB Khi snprintf sao chép n-1 byte, chúng ta phải gọi snprintf (buf, len + 1, "% ld", n) (không chỉ snprintf (buf, len, "% ld", n))

Chức năng itoa trong Linux ở đâu?

Không có chức năng như vậy trong Linux. Tôi sử dụng mã này để thay thế.

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

tôi đã thử triển khai itoa () của riêng mình, có vẻ như nó hoạt động ở dạng nhị phân, bát phân, thập phân và hex

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

sao chép trực tiếp vào bộ đệm: 64 bit 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];
    }

lưu ý: thay đổi dài thành dài dài cho máy 32 bit. dài đến int trong trường hợp cho số nguyên 32 bit. m là cơ số. Khi giảm cơ số, tăng số lượng ký tự (biến i). Khi tăng cơ số, giảm số lượng ký tự (tốt hơn). Trong trường hợp kiểu dữ liệu không dấu, tôi chỉ trở thành 16 + 1.

Đây là một phiên bản cải tiến của giải pháp Archana. Nó hoạt động cho mọi cơ số 1-16 và các số <= 0 và không nên ghi nhớ bộ nhớ.

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

Nếu bạn chỉ muốn in chúng:

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

Đọc mã của những kẻ làm việc đó để kiếm sống sẽ giúp bạn có được CÁCH DÀI.

Kiểm tra xem mọi người từ MySQL đã làm điều đó như thế nào. Nguồn là RẤT NHIỀU COMMENTED và sẽ dạy cho bạn nhiều hơn là các giải pháp hack được tìm thấy ở khắp mọi nơi.

MySQL triển khai int2str

Tôi cung cấp việc thực hiện được đề cập ở đây; liên kết ở đây để tham khảo và nên được sử dụng để đọc toàn bộ thực hiện.

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

Chức năng itoa trong Linux ở đâu?

Vì itoa()không phải là tiêu chuẩn trong C, các phiên bản khác nhau với các chữ ký chức năng khác nhau tồn tại.
char *itoa(int value, char *str, int base);là phổ biến trong * nix.

Nếu nó bị thiếu từ Linux hoặc nếu mã không muốn giới hạn tính di động, mã có thể làm cho nó sở hữu.

Dưới đây là phiên bản không gặp sự cố INT_MINvà xử lý bộ đệm có vấn đề: NULLhoặc trả về bộ đệm không đủ 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);
}

Dưới đây là phiên bản C99 trở lên xử lý mọi cơ sở [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);
}

Đối với mã tuân thủ C89 trở đi, hãy thay thế vòng lặp bên trong bằng

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

thực hiện nội bộ glibc

glibc 2.28 có triển khai nội bộ:

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

được sử dụng ở một số nơi trong nội bộ, nhưng tôi không thể tìm thấy nếu nó có thể được tiếp xúc hoặc làm thế nào.

Ít nhất đó phải là một triển khai mạnh mẽ nếu bạn sẵn sàng trích xuất nó.

Câu hỏi này hỏi làm thế nào để tự cuộn: Làm thế nào để chuyển đổi một int thành chuỗi trong C?

Tôi thích cái này: https://github.com/wsq003/itoa_for_linux

Nó phải là itoa () nhanh nhất từ ​​trước đến nay. Chúng tôi sử dụng itoa () thay vì sprintf () vì lý do hiệu suất, vì vậy một itoa () nhanh nhất với tính năng hạn chế là hợp lý và đáng giá.

Tôi đã sử dụng _itoa (...) trên trình biên dịch RedHat 6 và GCC. Nó hoạt động.

Việc thay thế bằng snprintf KHÔNG hoàn tất!

Nó chỉ bao gồm các cơ sở: 2, 8, 10, 16, trong khi itoa hoạt động cho các căn cứ từ 2 đến 36.

Vì tôi đang tìm kiếm một sự thay thế cho cơ sở 32, tôi đoán tôi sẽ phải tự viết mã!

Bạn có thể sử dụng chương trình này thay vì chạy nước rút.

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