लिनक्स में इटोआ फ़ंक्शन कहाँ है?

Question

itoa()एक नंबर को एक स्ट्रिंग में बदलने के लिए एक बहुत ही आसान कार्य है। लिनक्स के लिए प्रतीत नहीं होता है itoa(), क्या कोई समतुल्य फ़ंक्शन है या मुझे उपयोग करना है sprintf(str, "%d", num)?

Comments

उपयोग नहीं करने का कोई कारण sprintf(str, "%d", num)? क्या यह बहुत धीमी है itoa?

— 18

@javapowered, एक के लिए, itoaमनमाना आधार रूपांतरण की अनुमति देता है, printfविनिर्देशक नहीं।

— vladr

@javapowered स्प्रिंटफ () सिग्नल सुरक्षित नहीं है

— lunesco

gcvt()मानक पुस्तकालय से उपयोग करने का कोई कारण नहीं ?

— सुबिन सेबेस्टियन

Answer 1

संपादित करें: क्षमा करें, मुझे याद रखना चाहिए कि यह मशीन निश्चित रूप से गैर-मानक है, libcशैक्षिक उद्देश्यों के लिए विभिन्न गैर-मानक कार्यान्वयनों में प्लग की गई है;;

जैसा itoa()कि वास्तव में गैर-मानक है, जैसा कि कई सहायक टिप्पणीकारों द्वारा उल्लेख किया गया है, इसका उपयोग करना सबसे अच्छा है sprintf(target_string,"%d",source_int)या (अभी तक बेहतर है, क्योंकि यह बफर ओवरफ्लो से सुरक्षित है) snprintf(target_string, size_of_target_string_in_bytes, "%d", source_int)। मुझे पता है कि यह काफी संक्षिप्त या शांत नहीं है itoa(), लेकिन कम से कम आप एक बार लिख सकते हैं, हर जगह चला सकते हैं (tm ;-))

यहाँ पुराना (संपादित) उत्तर है

आप यह बताते हुए सही हैं कि डिफ़ॉल्ट gcc libcमें itoa()कई अन्य प्लेटफार्मों की तरह शामिल नहीं है, क्योंकि यह तकनीकी रूप से मानक का हिस्सा नहीं है। थोड़ी और जानकारी के लिए यहाँ देखें । ध्यान दें कि आपको करना है

#include <stdlib.h>

बेशक आप यह पहले से ही जानते हैं, क्योंकि आप लिनक्स पर किसी अन्य प्लेटफ़ॉर्म पर इसका उपयोग करने के बाद उपयोग करना चाहते थे itoa(), लेकिन ... कोड (ऊपर दिए गए लिंक से चुराया गया) इस तरह दिखेगा:

उदाहरण

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

आउटपुट:

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

उम्मीद है की यह मदद करेगा!

Comments

हम्म, संकलन करता है कि डेबियन पर मुझे "` शोए 'के लिए अपरिभाषित संदर्भ मिलता है। शायद मेरे सिस्टम में कुछ गड़बड़ है।

— एडम पियर्स

मुझे उबंटू 8.04 पर समान मिलता है। मैं stdio.h या stdlib.h में itoa के लिए कोई संदर्भ नहीं पा सकता (या मानक के भाग के बाद से सुपरराइजिंग नहीं है)

— camh

शुद्धता के लिए संपादित, धन्यवाद दोस्तों! क्षमा करें, मैं हमेशा भूल जाता हूं कि यह एक वैनिला लिनक्स बॉक्स नहीं है ;-)

— मैट जे

मैंने बफर आकार के तर्क को शामिल करने के लिए उत्तर संपादित किया है; मेरा मानना ​​है कि सब कुछ वैसा ही है जैसा अब होना चाहिए, मुझे किसी समस्या के तर्क के क्रम के साथ नहीं दिख रहा है। क्या मैं कुछ भूल रहा हूँ?

— मैट जे

यह लिनक्स के लिए काम नहीं करता है? प्रश्न / उत्तर का परिणाम क्या है (गैर मानक सभी

Answer 2

यदि आप इसे बहुत कुछ कह रहे हैं, तो "बस स्निपरफ का उपयोग करें" की सलाह कष्टप्रद हो सकती है। तो यहाँ आप क्या चाहते हैं:

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

Comments

टिप्पणी की तरह कहा :)

— जेम्स एंटिल

यह केवल गैर-थ्रेड सुरक्षित नहीं है, यह बिल्कुल भी सुरक्षित नहीं है: - void some_func (char * a, char * b); some_func (itoa (123), itoa (456)); यह अनुमान लगाने में सावधानी बरतें कि फ़ंक्शन क्या करता है?

— जॉकरोड

इसके अलावा, constक्वालिफायर फंक्शन रिटर्न प्रकारों पर कुछ नहीं करते हैं - आपको यह पता चल जाएगा कि आप कंपाइलर चेतावनियों को चालू कर चुके हैं :)

— कैट

@cat लेकिन यहाँ कोई भी कास्ट-योग्य रिटर्न प्रकार नहीं हैं। const char *नॉन-कास्ट पॉइंटर टू कॉन्स्ट है, जो बहुत मायने रखता है और सही है।

— चोर्टोस -2

@ Chortos-2 यह दिलचस्प है, आप निश्चित रूप से, पूरी तरह से सही हैं - मुझे इसके constबीच अर्थ में अंतर का एहसास नहीं हुआ const int f (void) { ...और const int* f (void) { ..., लेकिन अब इसे संकलक के साथ आज़माया गया है, यह समझ में आता है।

— बिल्ली

Answer 3

itoaएक मानक सी फ़ंक्शन नहीं है। आप अपना खुद का कार्यान्वयन कर सकते हैं। यह पृष्ठ 60 पर, कर्निघन और रिची की सी सी प्रोग्रामिंग भाषा के पहले संस्करण में दिखाई दिया । द सी प्रोग्रामिंग लैंग्वेज ("के एंड आर 2") के दूसरे संस्करण में निम्नलिखित itoa64 पृष्ठ शामिल हैं, इस कार्यान्वयन के लिए पुस्तक में कई नोट्स हैं। , इस तथ्य को शामिल करते हुए कि यह सबसे नकारात्मक संख्या को सही ढंग से नहीं संभालता है

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

reverseऊपर उपयोग किए गए फ़ंक्शन को दो पृष्ठों पहले लागू किया गया है:

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

Answer 4

संपादित करें: मुझे अभी पता चला है std::to_stringकि नीचे अपने स्वयं के फ़ंक्शन के लिए समान है। इसे C ++ 11 में पेश किया गया था और यह gcc के हाल के संस्करणों में उपलब्ध है, कम से कम 4.5 के रूप में यदि आप c ++ 0x एक्सटेंशन को सक्षम करते हैं।

---

न केवल itoaजीसीसी से गायब है, यह उपयोग करने के लिए सबसे आसान कार्य नहीं है क्योंकि आपको इसे बफर खिलाने की आवश्यकता है। मुझे एक ऐसी चीज की आवश्यकता थी जिसका उपयोग अभिव्यक्ति में किया जा सके इसलिए मैं इस पर आया:

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

आमतौर पर इसके snprintfबजाय इसका उपयोग करना अधिक सुरक्षित होगा , sprintfलेकिन बफर को सावधानीपूर्वक आकार देने के लिए प्रतिरक्षा से अधिक होना चाहिए।

एक उदाहरण देखें: http://ideone.com/mKmZVE

Comments

प्रश्न C के बारे में लगता है, जिसमें कोई std::सामान आदि नहीं है

— glglgl

Answer 5

जैसा कि मैट जे ने लिखा है itoa, लेकिन यह मानक नहीं है। यदि आप उपयोग करते हैं तो आपका कोड अधिक पोर्टेबल होगा snprintf।

Answer 6

निम्नलिखित फ़ंक्शन दी गई संख्या का स्ट्रिंग प्रतिनिधित्व रखने के लिए बस पर्याप्त मेमोरी आवंटित करता है और फिर मानक 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;
}

freeजब जरूरत से बाहर स्मृति को आवंटित करने के लिए मत भूलना :

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

NB के रूप में snprintf n-1 बाइट्स को कॉपी करता है, हमें snprintf (buf, len + 1, "% ld", n) (केवल snprintf (buf, len, "% ld", n) को कॉल करना होगा)

Comments

अपने फ़ंक्शन को कॉल करना एक अच्छा विचार नहीं है, itoaलेकिन itoaवास्तव में इसके सामान्य कार्यान्वयन के लिए इसे अलग व्यवहार दें । यह फ़ंक्शन एक ठीक विचार है, लेकिन इसे कुछ और कॉल करें :) मैं snprintfफ़्लोटिंग पॉइंट स्ट्रिंग के बजाय बफर लंबाई की गणना करने का उपयोग करने का सुझाव दूंगा; फ्लोटिंग पॉइंट में कोने का मामला गलत हो सकता है। और कॉलोक कास्ट न करें

— MM

सुझाव के लिए धन्यवाद।

— mmememirbas

labsयदि यह एक लंबा पूर्णांक लेने जा रहा है तो इसका उपयोग करना चाहिए । इसके अलावा यह छोटा हो सकता है।

— Schwern

snprintfएक निश्चित आकार के tmp बफर char buf[64]में लंबाई प्राप्त करना, mallocऔर फिर उस में कॉपी करना। आप नहीं से बाहर कोई लाभ मिल रहा है callocखत्म हो गया mallocहै, क्योंकि आप सभी बाइट्स लिखें। फ़्लोटिंग पॉइंट लॉग 10 को कॉल करने की तुलना में बहुत कम स्ट्रिंग की अतिरिक्त प्रतिलिपि कम खराब है। पूर्णांक लॉग 2 के साथ एक तेज सन्निकटन उपयोगी हो सकता है, हालांकि, यदि आपके पास एक बिट-स्कैन फ़ंक्शन है जो कि कुछ कुशल (जैसे bsrx86) के लिए विश्वसनीय रूप से इनलाइन होगा । (वैकल्पिक: mallocएक 64 बाइट बफर और उसके reallocबाद आपको अंतिम लंबाई पता है।)

— पीटर कॉर्ड्स

Answer 7

लिनक्स में इटोआ फ़ंक्शन कहाँ है?

लिनक्स में ऐसा कोई फंक्शन नहीं है। मैं इस कोड का उपयोग करता हूं।

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

Comments

आपको अपने उत्तर को यह समझाने के लिए संपादित करना चाहिए कि यह कोड प्रश्न का उत्तर कैसे देता है।

— सी। हीलिंग

Answer 8

मैं अपने खुद के itoa () के कार्यान्वयन की कोशिश की, यह द्विआधारी, अष्टाधारी, दशमलव और हेक्स में काम लगता है

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

Answer 9

बफ़र को सीधी कॉपी: 64 बिट पूर्णांक इटो हेक्स:

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

नोट: 32 बिट मशीन के लिए लंबे समय से लंबे समय तक बदलें। 32 बिट पूर्णांक के मामले में int के लिए लंबे समय तक। मी मूलांक है। मूलांक कम करते समय, वर्णों की संख्या बढ़ाएं (चर i)। मूलांक बढ़ाते समय, वर्णों की संख्या कम करें (बेहतर)। अहस्ताक्षरित डेटा प्रकार के मामले में, मैं सिर्फ 16 + 1 बन जाता हूं।

Answer 10

यहां अर्चना के समाधान का एक बहुत बेहतर संस्करण है। यह किसी भी मूलांक 1-16 के लिए काम करता है, और संख्या <= 0, और यह क्लोबर मेमोरी नहीं होनी चाहिए।

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

Answer 11

यदि आप उन्हें मुद्रित करना चाहते हैं:

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

Answer 12

जो लोग इसे जीने के लिए करते हैं, उनके कोड को पढ़ने से आपको लंबी छुट्टी मिलेगी।

देखें कि MySQL के लोगों ने यह कैसे किया। इसका स्रोत बहुत ही कम है और आपको हर जगह पाए गए समाधानों को हैक करने से ज्यादा सिखाएगा।

MySQL के int2str का कार्यान्वयन

मैं यहां उल्लिखित कार्यान्वयन प्रदान करता हूं; लिंक यहाँ संदर्भ के लिए है और इसका उपयोग पूर्ण कार्यान्वयन को पढ़ने के लिए किया जाना चाहिए।

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

Comments

संभावित समाधान का लिंक हमेशा स्वागत योग्य है, लेकिन कृपया लिंक के चारों ओर संदर्भ जोड़ें , ताकि आपके साथी उपयोगकर्ताओं को कुछ पता चले कि यह क्या है और यह क्यों है। हमेशा एक महत्वपूर्ण लिंक का सबसे प्रासंगिक हिस्सा उद्धृत करें, यदि लक्ष्य साइट उपलब्ध नहीं है या स्थायी रूप से ऑफ़लाइन है। इस बात का ध्यान रखें कि किसी बाहरी साइट के लिंक से मुश्किल से अधिक होना एक संभावित कारण है कि कुछ उत्तरों को क्यों और कैसे हटाया जाता है? ।

— तुनकी

तो क्या आप यहाँ पोस्ट की गई स्निपेट के बारे में बहुत अच्छा है? भविष्य के पाठकों को क्या देखना चाहिए?

— मार्टिन पीटर्स

Answer 13

लिनक्स में इटोआ फ़ंक्शन कहाँ है?

जैसा कि itoa()सी में मानक नहीं है, विभिन्न फ़ंक्शन हस्ताक्षर वाले विभिन्न संस्करण मौजूद हैं।
char *itoa(int value, char *str, int base);* निक्स में आम है।

क्या यह लिनक्स से गायब होना चाहिए या यदि कोड पोर्टेबिलिटी को सीमित नहीं करना चाहता है, तो कोड इसे स्वयं बना सकता है।

नीचे एक ऐसा संस्करण दिया गया है जिसमें INT_MINसमस्या नहीं है और समस्या बफ़र को हैंडल करता है: NULLया अपर्याप्त बफर रिटर्न 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);
}

---

नीचे एक C99 या बाद का संस्करण है जो किसी भी आधार को संभालता है [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);
}

C89 और आगे के अनुरूप कोड के लिए, आंतरिक लूप को बदलें

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

Answer 14

glibc आंतरिक कार्यान्वयन

glibc 2.28 में आंतरिक कार्यान्वयन है:

• stdio-आम / _itoa.c
• sysdeps / सामान्य / _itoa.h

जिसका उपयोग कई स्थानों पर आंतरिक रूप से किया जाता है, लेकिन मुझे पता नहीं चल पाया है कि इसे उजागर किया जा सकता है या कैसे।

यदि आप इसे निकालने के इच्छुक हैं तो कम से कम एक मजबूत कार्यान्वयन होना चाहिए।

यह प्रश्न पूछता है कि अपना रोल कैसे बनाएं: C में स्ट्रिंग को इंट में कैसे बदलें?

Answer 15

मैं इसे पसंद करूंगा: https://github.com/wsq003/itoa_for_linux

यह सबसे तेज इटोआ () होना चाहिए। हम प्रदर्शन कारण के लिए स्प्रिंट () के बजाय इटोआ () का उपयोग करते हैं, इसलिए सीमित सुविधा वाला सबसे तेज़ इटोआ () उचित और सार्थक है।

Answer 16

मैंने RedHat 6 और GCC कंपाइलर पर _itoa (...) का उपयोग किया है। यह काम करता हैं।

Answer 17

Snprintf के साथ प्रतिस्थापन पूरा नहीं हुआ है!

यह केवल आधारों को कवर करता है: 2, 8, 10, 16, जबकि इटोआ 2 और 36 के बीच अड्डों के लिए काम करता है।

जब से मैं बेस 32 के लिए एक प्रतिस्थापन खोज रहा था, मुझे लगता है कि मुझे अपना कोड खुद करना होगा!

Answer 18

आप स्प्रिंट के बजाय इस कार्यक्रम का उपयोग कर सकते हैं।

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

Comments

इस कोड में बहुत सारे कीड़े हैं: 1) वास्तव में हेक्स को सही तरीके से परिवर्तित नहीं करता है। 2) 0 को बिल्कुल भी परिवर्तित नहीं करता है। 3) नकारात्मक संख्याओं के साथ काम नहीं करता है। 4) बफर उगाने के लिए कोई जाँच नहीं। मैं शीघ्र ही इस कोड का एक बेहतर संस्करण पोस्ट करूंगा।

— क्रिस डेसजार्डिन्स