Di mana fungsi itoa di Linux?

itoa()adalah fungsi yang sangat berguna untuk mengubah angka menjadi string. Linux sepertinya tidak punya itoa(), apakah ada fungsi yang setara atau harus saya gunakan sprintf(str, "%d", num)?

EDIT: Maaf, saya seharusnya ingat bahwa mesin ini jelas-jelas tidak standar, telah terpasang di berbagai libcimplementasi non-standar untuk keperluan akademik ;-)

Karena itoa()memang tidak standar, seperti yang disebutkan oleh beberapa komentator yang membantu, yang terbaik adalah menggunakan sprintf(target_string,"%d",source_int)atau (lebih baik lagi, karena aman dari buffer overflows) snprintf(target_string, size_of_target_string_in_bytes, "%d", source_int). Saya tahu itu tidak begitu ringkas atau sejukitoa() , tetapi setidaknya Anda dapat Menulis Sekali, Jalankan Di Mana Saja (tm) ;-)

Inilah jawaban lama (yang diedit)

Anda benar dalam menyatakan bahwa default gcc libctidak termasuk itoa(), seperti beberapa platform lain, karena itu secara teknis tidak menjadi bagian dari standar. Lihat di sini untuk info lebih lanjut. Perhatikan bahwa Anda harus melakukannya

#include <stdlib.h>

Tentu saja Anda sudah tahu ini, karena Anda ingin menggunakannya itoa() di Linux setelah mungkin menggunakannya di platform lain, tapi ... kodenya (dicuri dari tautan di atas) akan terlihat seperti:

Contoh

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

Keluaran:

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

Semoga ini membantu!

Jika Anda sering menyebutnya, saran "gunakan saja snprintf" dapat mengganggu. Jadi inilah yang mungkin Anda inginkan:

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

itoabukan fungsi standar C. Anda bisa menerapkannya sendiri. Itu muncul dalam edisi pertama Kernighan dan Ritchie's The C Programming Language , di halaman 60. Edisi kedua The C Programming Language ("K & R2") berisi implementasi berikut itoa, pada halaman 64. Buku ini mencatat beberapa masalah dengan implementasi ini , termasuk fakta bahwa ia tidak menangani angka paling negatif dengan benar

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

Fungsi yang reversedigunakan di atas diimplementasikan dua halaman sebelumnya:

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

Sunting: Saya baru tahustd::to_string yang identik dalam operasi dengan fungsi saya sendiri di bawah ini. Itu diperkenalkan di C ++ 11 dan tersedia dalam versi terbaru gcc, setidaknya pada awal 4,5 jika Anda mengaktifkan ekstensi 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);
}

Biasanya itu akan lebih aman untuk digunakan snprintfdaripadasprintf tetapi buffer dengan hati-hati berukuran kebal terhadap overrun.

Lihat contoh: http://ideone.com/mKmZVE

Seperti yang ditulis Matt J, ada itoa, tapi itu bukan standar. Kode Anda akan lebih portabel jika Anda gunakan snprintf.

Fungsi berikut mengalokasikan memori yang cukup untuk menjaga representasi string dari angka yang diberikan dan kemudian menulis representasi string ke area ini menggunakan sprintfmetode standar .

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

Jangan lupa untuk freemenambah alokasi memori saat dibutuhkan:

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

NB Saat snprintf menyalin n-1 byte, kita harus memanggil snprintf (buf, len + 1, "% ld", n) (bukan hanya snprintf (buf, len, "% ld", n))

Di mana fungsi itoa di Linux?

Tidak ada fungsi seperti itu di Linux. Saya menggunakan kode ini sebagai gantinya.

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

saya mencoba implementasi itoa () saya sendiri, sepertinya berfungsi dalam biner, oktal, desimal dan 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;
}

copy langsung ke buffer: 64 bit integer 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];
    }

Catatan: ubah panjang ke panjang untuk mesin 32 bit. panjang ke int jika untuk integer 32 bit. m adalah radix. Ketika mengurangi radix, menambah jumlah karakter (variabel i). Saat menambah radix, kurangi jumlah karakter (lebih baik). Dalam hal tipe data yang tidak ditandatangani, saya hanya menjadi 16 + 1.

Ini adalah versi yang lebih baik dari solusi Archana. Ini bekerja untuk semua radix 1-16, dan angka <= 0, dan itu tidak akan merusak memori.

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

Jika Anda hanya ingin mencetaknya:

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

Membaca kode orang-orang yang melakukannya untuk mencari nafkah akan memberi Anda CARA PANJANG.

Lihatlah bagaimana orang-orang dari MySQL melakukannya. Sumbernya SANGAT BAIK DIPERBOLEHKAN dan akan mengajarkan Anda lebih dari sekadar solusi yang ditemukan di semua tempat.

Implementasi int2str dari MySQL

Saya memberikan implementasi yang disebutkan di sini; tautan di sini untuk referensi dan harus digunakan untuk membaca implementasi penuh.

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

Di mana fungsi itoa di Linux?

Karena itoa()tidak standar dalam C, berbagai versi dengan berbagai tanda tangan fungsi ada.
char *itoa(int value, char *str, int base);umum di * nix.

Haruskah itu hilang dari Linux atau jika kode tidak ingin membatasi portabilitas, kode dapat membuatnya sendiri.

Di bawah ini adalah versi yang tidak memiliki masalah dengan INT_MINdan menangani buffer masalah: NULLatau buffer tidak mencukupi 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);
}

Di bawah ini adalah versi C99 atau lebih baru yang menangani basis apa pun [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);
}

Untuk kode yang sesuai dengan C89 dan selanjutnya, ganti loop dalam dengan

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

implementasi internal glibc

glibc 2.28 memiliki implementasi internal:

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

yang digunakan di beberapa tempat secara internal, tetapi saya tidak dapat menemukan apakah itu bisa diekspos atau bagaimana.

Setidaknya itu harus menjadi implementasi yang kuat jika Anda ingin mengekstraknya.

Pertanyaan ini menanyakan bagaimana cara menggulung sendiri: Bagaimana mengonversi int ke string dalam C?

Saya lebih suka ini: https://github.com/wsq003/itoa_for_linux

Ini harus menjadi itoa tercepat () yang pernah ada. Kami menggunakan itoa () alih-alih sprintf () karena alasan kinerja, jadi itoa tercepat () dengan fitur terbatas masuk akal dan bermanfaat.

Saya telah menggunakan _itoa (...) pada RedHat 6 dan GCC compiler. Berhasil.

Pengganti dengan snprintf TIDAK lengkap!

Ini hanya mencakup basis: 2, 8, 10, 16, sedangkan itoa bekerja untuk basis antara 2 dan 36.

Karena saya mencari pengganti base 32, saya kira saya harus membuat kode sendiri!

Anda dapat menggunakan program ini alih-alih 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);
}