blocks|key|1721617|text|如果你经常调用它，“只使用snprintf”的建议可能会很烦人。所以这可能是你想要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721618|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,+"%25d",+num)+==+-1)
++++return+"";+/*+or+whatever+*/

++return+buf;
}

const+char+*my_itoa(int+num)
{+return+my_itoa_buf(NULL,+0,+num);+}|code-block|syntax|javascript|1721619|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you are calling it a lot, the advice of "just use snprintf" can be annoying. So here's what you probably want:

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

blocks|key|1721523|text|正如Matt+J所写的，有itoa，但它不是标准的。如果你使用snprintf，你的代码将会更容易移植。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1721524|entityMap^0|D|4|V|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

As Matt J wrote, there is <code>itoa</code>, but it's not standard. Your code will be more portable if you use <code>snprintf</code>.

blocks|key|1721739|text|下面的函数分配足够的内存来保存给定数字的字符串表示，然后使用标准的sprintf方法将字符串表示写入该区域。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1721740|char+*itoa(long+n)
{
++++int+len+=+n==0+?+1+:+floor(log10l(labs(n)))%2B1;
++++if+(n<0)+len%2B%2B;+//+room+for+negative+sign+'-'

++++char++++*buf+=+calloc(sizeof(char),+len%2B1);+//+%2B1+for+null
++++snprintf(buf,+len%2B1,+"%25ld",+n);
++++return+++buf;
}|code-block|syntax|javascript|1721741|当不需要时，不要忘记free分配的内存：|1721742|char+*num_str+=+itoa(123456789L);
//+...+
free(num_str);|1721743|注意:当snprintf拷贝n-1个字节时，我们必须调用snprintf(buf，len%2B1，"%25ld"，n)+(不仅仅是snprintf(buf，len，"%25ld"，n))|1721744|entityMap^0|X|7|0|0|A|4|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Following function allocates just enough memory to keep string representation of the given number and then writes the string representation into this area using standard <code>sprintf</code> method.

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

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

Don't forget to <code>free</code> up allocated memory when out of need:

<pre><code>char *num_str = itoa(123456789L);
// ... 
free(num_str);
</code></pre>

N.B. As snprintf copies n-1 bytes, we have to call snprintf(buf, len+1, "%ld", n) (not just snprintf(buf, len, "%ld", n))

blocks|key|1721995|text|阅读那些以此为生的人的代码会让你走很长一段路。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721996|看看MySQL的人是怎么做到的。这个源码得到了很好的评论，它将教给你更多的东西，而不是到处都能找到的解决方案。|1721997|MySQL's+implementation+of+int2str|offset|length|1721998|我在这里提供了提到的实现；这里的链接是为了参考，应该用来阅读完整的实现。|1721999|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+%7C%7C+radix+>+-2)
++++++return+NullS;
++++if+(val+<+0)
++++{
++++++*dst%2B%2B+=+'-';
++++++/*+Avoid+integer+overflow+in+(-val)+for+LLONG_MIN+(BUG#31799).+*/
++++++uval+=+(ulong)0+-+uval;
++++}
++++radix+=+-radix;
++}
++else+if+(radix+>+36+%7C%7C+radix+<+2)
++++return+NullS;

++/*
++++The+slightly+contorted+code+which+follows+is+due+to+the+fact+that
++++few+machines+directly+support+unsigned+long+/+and+%25.++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+%25+and+/+should+be+unsigned,+the+second
++++%25+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%2B%2B+=+*p%2B%2B)+!=+0)+;
++return+dst-1;
}|code-block|syntax|javascript|1722000|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/mysql/mysql-server/blob/5.7/strings/int2str.c^0|0|0|0|X|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Reading the code of guys who do it for a living will get you a LONG WAY.

Check out how guys from MySQL did it. The source is VERY WELL COMMENTED and will teach you much more than hacked up solutions found all over the place.

<a href="https://github.com/mysql/mysql-server/blob/5.7/strings/int2str.c" rel="nofollow">MySQL's implementation of int2str</a>

I provide the mentioned implementation here; the link is here for reference and should be used to read the full implementation.

<pre><code>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 &lt; 0)
 {
 if (radix &lt; -36 || radix &gt; -2)
 return NullS;
 if (val &lt; 0)
 {
 *dst++ = '-';
 /* Avoid integer overflow in (-val) for LLONG_MIN (BUG#31799). */
 uval = (ulong)0 - uval;
 }
 radix = -radix;
 }
 else if (radix &gt; 36 || radix &lt; 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 = &amp;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;
}
</code></pre>

blocks|key|1506727|text|我尝试了我自己的itoa()实现，它似乎是二进制、八进制、十进制和十六进制的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506728|#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%2B1];


++++switch(base)
++++{
++++++++case+16:
++++++++++++for(i+=+0;i<HEX_LEN;%2B%2Bi)
++++++++++++{
++++++++++++++++if(value/base>0)
++++++++++++++++{
++++++++++++++++++++n%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++++++snprintf(str,+n,+"%25x"+,value);
++++++++++++break;
++++++++case+10:
++++++++++++for(i+=+0;i<INT_LEN;%2B%2Bi)
++++++++++++{
++++++++++++++++if(value/base>0)
++++++++++++++++{
++++++++++++++++++++n%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++++++snprintf(str,+n,+"%25d"+,value);
++++++++++++break;
++++++++case+8:
++++++++++++for(i+=+0;i<OCT_LEN;%2B%2Bi)
++++++++++++{
++++++++++++++++if(value/base>0)
++++++++++++++++{
++++++++++++++++++++n%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++++++snprintf(str,+n,+"%25o"+,value);
++++++++++++break;
++++++++case+2:
++++++++++++for(i+=+0,tmp+=+value;i<BIN_LEN;%2B%2Bi)
++++++++++++{
++++++++++++++++if(tmp/base>0)
++++++++++++++++{
++++++++++++++++++++n%2B%2B;
++++++++++++++++}
++++++++++++++++tmp/=base;
++++++++++++}
++++++++++++for(i+=+1+,tmp+=+value;+i<n;%2B%2Bi)
++++++++++++{
++++++++++++++++if(tmp%252+!=+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;
}|code-block|syntax|javascript|1506729|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i tried my own implementation of itoa(), it seem's work in binary, octal, decimal and hex

<pre><code>#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&lt;HEX_LEN;++i)
 {
 if(value/base&gt;0)
 {
 n++;
 }
 }
 snprintf(str, n, "%x" ,value);
 break;
 case 10:
 for(i = 0;i&lt;INT_LEN;++i)
 {
 if(value/base&gt;0)
 {
 n++;
 }
 }
 snprintf(str, n, "%d" ,value);
 break;
 case 8:
 for(i = 0;i&lt;OCT_LEN;++i)
 {
 if(value/base&gt;0)
 {
 n++;
 }
 }
 snprintf(str, n, "%o" ,value);
 break;
 case 2:
 for(i = 0,tmp = value;i&lt;BIN_LEN;++i)
 {
 if(tmp/base&gt;0)
 {
 n++;
 }
 tmp/=base;
 }
 for(i = 1 ,tmp = value; i&lt;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;
}
</code></pre>

blocks|key|1721786|text|直接复制到缓冲区:+64位整数itoa十六进制：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721787|++++char*+itoah(long+num,+char*+s,+int+len)
++++{
++++++++++++long+n,+m+=+16;
++++++++++++int+i+=+16%2B2;
++++++++++++int+shift+=+'a'-+('9'%2B1);


++++++++++++if(!s+%7C%7C+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+%25+m+%2B+'0';

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

++++++++++++++++++++n+=+n/m;
++++++++++++++++++++i--;
++++++++++++}

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

++++++++++++return+&s[i];
++++}|code-block|syntax|javascript|1721788|注意:对于32位机器，将long改为long+long。对于32位整数，从long到int。M是基数。当减少基数时，增加字符数(变量i)。当增加基数时，减少字符数(更好)。在无符号数据类型的情况下，我变成了16+%2B+1。|1721789|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

direct copy to buffer : 64 bit integer itoa hex :

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


 if(!s || len &lt; 1)
 return 0;

 n = num &lt; 0 ? -1 : 1;
 n = n * num;

 len = len &gt; i ? i : len;
 i = len &lt; i ? len : i;

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

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

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

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

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

 n = n/m;
 i--;
 }

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

 return &amp;s[i];
 }
</code></pre>

note: change long to long long for 32 bit machine. long to int in case for 32 bit integer. m is the radix. When decreasing radix, increase number of characters (variable i). When increasing radix, decrease number of characters (better). In case of unsigned data type, i just becomes 16 + 1.

blocks|key|1506670|text|以下是Archana解决方案的一个大大改进的版本。它适用于任何基数1-16，数字<=为0，并且不会占用内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506671|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%2B%2B)
++++{
++++++++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%2B%2B]+=+'-';
++++++++++++buffer[len]+=+'\0';
++++++++}
++++}
++++else
++++{
++++++++int+twosCompIndex+=+0;
++++++++for+(int+index+=+0;+index+<+len;+index%2B%2B)
++++++++{
++++++++++++if+((buffer[index]+>=+'0')+&&+(buffer[index]+<=+'9'))
++++++++++++{
++++++++++++++++twosCompIndex+=+buffer[index]+-+'0';
++++++++++++}
++++++++++++else+if+((buffer[index]+>=+'A')+&&+(buffer[index]+<=+'F'))
++++++++++++{
++++++++++++++++twosCompIndex+=+buffer[index]+-+'A'+%2B+10;
++++++++++++}
++++++++++++else+if+((buffer[index]+>=+'a')+&&+(buffer[index]+<=+'f'))
++++++++++++{
++++++++++++++++twosCompIndex+=+buffer[index]+-+'a'+%2B+10;
++++++++++++}
++++++++++++twosCompIndex+%2B=+(16+-+radix);
++++++++++++buffer[index]+=+_twosComp[twosCompIndex];
++++++++}
++++++++if+(len+<+(bufferSize+-+1))
++++++++{
++++++++++++buffer[len%2B%2B]+=+_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+%25+radix);
++++++++++++++++buffer[strlen%2B%2B]+=+_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;
}|code-block|syntax|javascript|1506672|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a much improved version of Archana's solution. It works for any radix 1-16, and numbers &lt;= 0, and it shouldn't clobber memory. 

<pre><code>static char _numberSystem[] = "0123456789ABCDEF";
static char _twosComp[] = "FEDCBA9876543210";

static void safestrrev(char *buffer, const int bufferSize, const int strlen)
{
 int len = strlen;
 if (len &gt; bufferSize)
 {
 len = bufferSize;
 }
 for (int index = 0; index &lt; (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 &gt; bufferSize)
 {
 len = bufferSize;
 }
 if (radix == 10)
 {
 if (len &lt; (bufferSize - 1))
 {
 buffer[len++] = '-';
 buffer[len] = '\0';
 }
 }
 else
 {
 int twosCompIndex = 0;
 for (int index = 0; index &lt; len; index++)
 {
 if ((buffer[index] &gt;= '0') &amp;&amp; (buffer[index] &lt;= '9'))
 {
 twosCompIndex = buffer[index] - '0';
 }
 else if ((buffer[index] &gt;= 'A') &amp;&amp; (buffer[index] &lt;= 'F'))
 {
 twosCompIndex = buffer[index] - 'A' + 10;
 }
 else if ((buffer[index] &gt;= 'a') &amp;&amp; (buffer[index] &lt;= 'f'))
 {
 twosCompIndex = buffer[index] - 'a' + 10;
 }
 twosCompIndex += (16 - radix);
 buffer[index] = _twosComp[twosCompIndex];
 }
 if (len &lt; (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 &lt; 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 &lt;= 16)
 {
 do
 {
 if (strlen &lt; (bufferSize - 1))
 {
 nuberSystemIndex = (n % radix);
 buffer[strlen++] = _numberSystem[nuberSystemIndex];
 buffer[strlen] = '\0';
 n = n / radix;
 }
 else
 {
 break;
 }
 } while (n != 0);
 if (x &lt; 0)
 {
 strlen = negateBuffer(buffer, bufferSize, strlen, radix);
 }
 safestrrev(buffer, bufferSize, strlen);
 return buffer;
 }
 return NULL;
}
</code></pre>

blocks|key|1506754|text|如果您只想打印它们：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506755|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");
}+|code-block|syntax|javascript|1506756|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you just want to print them:

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

 }
 printf("\n");
} 
</code></pre>

blocks|key|1506921|text|我更喜欢这样：https://github.com/wsq003/itoa_for_linux|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1506922|它应该是有史以来最快的itoa()。出于性能原因，我们使用itoa()而不是sprintf()，因此一个速度最快、功能有限的itoa()是合理的，也是值得的。|1506923|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/wsq003/itoa_for_linux^0|7|14|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

I would prefer this: <a href="https://github.com/wsq003/itoa_for_linux" rel="nofollow noreferrer">https://github.com/wsq003/itoa_for_linux</a>

It should be the fastest itoa() ever. We use itoa() instead of sprintf() for performance reason, so a fastest itoa() with limited feature is reasonable and worthwhile.

blocks|key|1506863|text|用snprintf替换没有完成！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506864|它只覆盖基地:+2，8，10，16，而itoa在2到36之间的基地工作。|1506865|由于我正在寻找32进制的替代品，我想我将不得不编写自己的代码！|1506866|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The replacement with snprintf is NOT complete!

It covers only bases: 2, 8, 10, 16, whereas itoa works for bases between 2 and 36.

Since I was searching a replacement for base 32, I guess I'll have to code my own!

blocks|key|1506381|text|我使用过_itoa(...)在RedHat+6和GCC编译器上。它起作用了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506382|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I have used _itoa(...) on RedHat 6 and GCC compiler. It works.

blocks|key|1506474|text|你可以使用这个程序而不是sprintf。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506475|void+itochar(int+x,+char+*buffer,+int+radix);

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

void+itochar(int+x,+char+*buffer,+int+radix)
{
++++int+i+=+0+,+n,s;
++++n+=+s;
++++while+(n+>+0)
++++{
++++++++s+=+n%25radix;
++++++++n+=+n/radix;
++++++++buffer[i%2B%2B]+=+'0'+%2B+s;
++++}
++++buffer[i]+=+'\0';
++++strrev(buffer);
}|code-block|syntax|javascript|1506476|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use this program instead of sprintf.

<pre><code>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 &gt; 0)
 {
 s = n%radix;
 n = n/radix;
 buffer[i++] = '0' + s;
 }
 buffer[i] = '\0';
 strrev(buffer);
}
</code></pre>

<code>itoa()</code> is a really handy function to convert a number to a string. Linux does not seem to have <code>itoa()</code>, is there an equivalent function or do I have to use <code>sprintf(str, "%d", num)</code>?

Where is the itoa function in Linux?

itoa()是一个非常方便的将数字转换为字符串的函数。Linux似乎没有itoa()，有没有等同的功能，或者我必须使用sprintf(str, "%d", num)

问在Linux中itoa函数在哪里？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Linux中itoa函数在哪里？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Linux中itoa函数在哪里？
EN