blocks|key|1101671|text|如果你被允许使用库函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101672|int+x+=+SOME_INTEGER;
char+res[5];+/*+two+bytes+of+hex+=+4+characters,+plus+NULL+terminator+*/

if+(x+<=+0xFFFF)
{
++++sprintf(&res[0],+"%2504x",+x);
}|code-block|syntax|javascript|1101673|您的整数可能包含四位以上的十六进制数字的数据，因此首先进行检查。|1101674|如果您不允许使用库函数，请手动将其划分为nybbles：|1101675|#define+TO_HEX(i)+(i+<=+9+?+'0'+%2B+i+:+'A'+-+10+%2B+i)

int+x+=+SOME_INTEGER;
char+res[5];

if+(x+<=+0xFFFF)
{
++++res[0]+=+TO_HEX(((x+&+0xF000)+>>+12));+++
++++res[1]+=+TO_HEX(((x+&+0x0F00)+>>+8));
++++res[2]+=+TO_HEX(((x+&+0x00F0)+>>+4));
++++res[3]+=+TO_HEX((x+&+0x000F));
++++res[4]+=+'\0';
}|1101676|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you're allowed to use library functions:

<pre><code>int x = SOME_INTEGER;
char res[5]; /* two bytes of hex = 4 characters, plus NULL terminator */

if (x &lt;= 0xFFFF)
{
 sprintf(&amp;res[0], "%04x", x);
}
</code></pre>

Your integer may contain more than four hex digits worth of data, hence the check first.

If you're not allowed to use library functions, divide it down into nybbles manually:

<pre><code>#define TO_HEX(i) (i &lt;= 9 ? '0' + i : 'A' - 10 + i)

int x = SOME_INTEGER;
char res[5];

if (x &lt;= 0xFFFF)
{
 res[0] = TO_HEX(((x &amp; 0xF000) &gt;&gt; 12)); 
 res[1] = TO_HEX(((x &amp; 0x0F00) &gt;&gt; 8));
 res[2] = TO_HEX(((x &amp; 0x00F0) &gt;&gt; 4));
 res[3] = TO_HEX((x &amp; 0x000F));
 res[4] = '\0';
}
</code></pre>

blocks|key|886784|text|假设int为32位；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886785|最简单的方法:只使用sprintf()|886786|int+intval+=+/*your+value*/
char+hexval[5];
sprintf(hexval,"%250x",intval);|code-block|syntax|javascript|886787|现在通过hexval3使用十六进制；如果希望将其用作以空结尾的字符串，则添加hexval[4]=0;|offset|length|style|CODE|886788|entityMap^0|0|0|0|12|C|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Assuming int to be 32 bits;

easiest way: just use sprintf()

<pre><code>int intval = /*your value*/
char hexval[5];
sprintf(hexval,"%0x",intval);
</code></pre>

Now use hexval[0] thru hexval[3]; if you want to use it as a null-terminated string then add <code>hexval[4]=0;</code>

blocks|key|1101944|text|我想出了一种快速的方法，我测试了一下，它起作用了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101945|int+value+=+11;

array[0]+=+value+>>+8;
array[1]+=+value+&+0xff;

printf("%25x%25x",+array[0],+array[1]);|code-block|syntax|javascript|1101946|结果是：|1101947|000B|1101948|它是十六进制的11。|1101949|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Figured out a quick way that I tested out and it works.

<pre><code>int value = 11;

array[0] = value &gt;&gt; 8;
array[1] = value &amp; 0xff;

printf("%x%x", array[0], array[1]);
</code></pre>

result is:

<pre><code>000B
</code></pre>

which is 11 in hex.

blocks|key|886715|text|char+s[5];++//+4+chars+%2B+'\0'
int+x+=+4660;
sprintf(s,+"%2504X",+x);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|886716|您可能需要查看sprintf()文档。注意这段代码不是很安全。如果x大于0xFFFF，则最终的字符串将超过4个字符，因此不适合。为了让它更安全，看看snprintf()。|unstyled|offset|length|style|CODE|886717|entityMap^0|0|7|9|X|1|10|6|22|A|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>char s[5]; // 4 chars + '\0'
int x = 4660;
sprintf(s, "%04X", x);
</code></pre>

You'll probably want to check <code>sprintf()</code> documentation. Be careful that this code is not very safe. If <code>x</code> is larger than <code>0xFFFF</code>, the final string will have more than 4 characters and won't fit. In order to make it safer, look at <code>snprintf()</code>.

blocks|key|1101831|text|通常，我会推荐使用其他人推荐的基于sprintf的解决方案。但是当我写了一个必须将数十亿项转换成十六进制的工具时，sprintf太慢了。对于该应用程序，我使用了256个元素的数组，它将字节映射到字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1101832|这是一个不完整的转换1字节的解决方案，不要忘记添加边界检查，并确保数组是静态的或全局的，为每次检查重新创建它会降低性能。|1101833|static+const+char+hexvals[][3]=+{"00",+"01",+"02",+...+"FD",+"FE",+"FF"};
const+char+*byteStr+=+hexvals[number];|code-block|syntax|javascript|1101834|entityMap^0|H|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Normally I would recommend using the <code>sprintf</code> based solutions recommended by others. But when I wrote a tool that had to convert billions of items to hex, sprintf was too slow. For that application I used a 256 element array, which maps bytes to strings.

This is an incomplete solution for converting 1 byte, don't forget to add bounds checking, and make sure the array is static or global, recreating it for every check would kill performance.

<pre><code>static const char hexvals[][3]= {"00", "01", "02", ... "FD", "FE", "FF"};
const char *byteStr = hexvals[number];
</code></pre>

blocks|key|1101706|text|我建议使用snprintf而不是sprintf。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1101707|#include+<stdio.h>

int+main()
{
++++char+output[5];
++++snprintf(output,5,"%2504x",255);

++++printf("%25s\n",output);
++++return+0;
}|code-block|syntax|javascript|1101708|它更安全，并且在几乎所有的编译器中都有。|1101709|entityMap^0|5|8|G|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Rather than <code>sprintf</code>, I would recommend using <code>snprintf</code> instead.

<pre><code>#include &lt;stdio.h&gt;

int main()
{
 char output[5];
 snprintf(output,5,"%04x",255);

 printf("%s\n",output);
 return 0;
}
</code></pre>

Its a lot safer, and is available in pretty much every compiler.

blocks|key|1102049|text|void+intToHex(int+intnumber,+char+*txt)
{++++
++++unsigned+char+_s4='0';
++++char+i=4;
++++//intnumber=0xffff;

++++do+{
++++++++i--;
++++++++_s4+=+(unsigned+char)++((intnumber+>>+i*4+)+&+0x000f);
++++++++if(_s4<10)
++++++++++++_s4=_s4%2B48;
++++++++else
++++++++++++_s4=_s4%2B55;

++++++++*txt%2B%2B=+_s4;++++
++++}+while(i);+++++
}
...
char+text+[5]={0,0,0,0,0};
...

intToHex(65534,text);
USART_Write_Text(text);
....|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1102050|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>void intToHex(int intnumber, char *txt)
{ 
 unsigned char _s4='0';
 char i=4;
 //intnumber=0xffff;

 do {
 i--;
 _s4 = (unsigned char) ((intnumber &gt;&gt; i*4 ) &amp; 0x000f);
 if(_s4&lt;10)
 _s4=_s4+48;
 else
 _s4=_s4+55;

 *txt++= _s4; 
 } while(i); 
}
...
char text [5]={0,0,0,0,0};
...

intToHex(65534,text);
USART_Write_Text(text);
....
</code></pre>

blocks|key|1101549|text|也许可以尝试一下这样的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101550|void+IntToHex(int+value,+char*+buffer)+{
++int+a+=+value&16;
++int+b+=+(value>>4)&16;
++buffer[0]+=+(a<10)?'0'%2Ba:'A'-(a-10);
++buffer[1]+=+(b<10)?'0'%2Bb:'A'-(b-10);
}|code-block|syntax|javascript|1101551|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|$]]

Perhaps try something like this:

<pre><code>void IntToHex(int value, char* buffer) {
 int a = value&amp;16;
 int b = (value&gt;&gt;4)&amp;16;
 buffer[0] = (a&lt;10)?'0'+a:'A'-(a-10);
 buffer[1] = (b&lt;10)?'0'+b:'A'-(b-10);
}
</code></pre>

blocks|key|886932|text|这些答案中的大多数都很棒，我只想补充一点:你可以使用sizeof安全地保留正确的字节数。每个字节最多可以包含两个十六进制数字(255+->+ff)，因此每个字节是两个字符。在本例中，我为'0x‘前缀添加了两个字符，为结尾NUL添加了一个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886933|int+bar;+
//+...
char+foo[sizeof(bar)+*+2+%2B+3];
sprintf(foo,+"0x%25x",+bar);|code-block|syntax|javascript|886934|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|$]]

Most of these answers are great, there's just one thing I'd add: you can use sizeof to safely reserve the correct number of bytes. Each byte can take up to two hex digits (255 -> ff), so it's two characters per byte. In this example I add two characters for the '0x' prefix and one character for the trailing NUL.

<pre><code>int bar; 
// ...
char foo[sizeof(bar) * 2 + 3];
sprintf(foo, "0x%x", bar);
</code></pre>

blocks|key|1101787|text|unsigned+int+hex16+=+((unsigned+int)+input_int)+&+0xFFFF;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1101788|input_int是要转换的数字。hex16将具有最低有效的2个字节的input_int。如果您希望将其打印到控制台，请使用%25x而不是%25d作为格式说明符，它将以十六进制格式打印。|unstyled|offset|length|style|CODE|1101789|entityMap^0|0|0|9|H|5|Z|9|1Q|2|1V|2|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>unsigned int hex16 = ((unsigned int) input_int) &amp; 0xFFFF;
</code></pre>

<code>input_int</code> is the number you want to convert. <code>hex16</code> will have the least significant 2 bytes of <code>input_int</code>. If you want to print it to the console, use <code>%x</code> as the format specifier instead of <code>%d</code> and it will be printed in hex format.

blocks|key|887073|text|这是一种简单的方法。如果我们不能相信ascii值的编码是连续的，我们只需要在char中创建一个十六进制值的映射。也许可以被优化，整理，变得更漂亮。还假设我们只捕获最后32位==+4个十六进制字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|887074|#include+<stdlib.h>
#include+<stdio.h>

#define+BUFLEN+5

int+main(int+argc,+char*+argv[])
{
++int+n,+i,+cn;
++char+c,+buf[5];
++char+hexmap[17]+=+{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','.'};

++for(i=0;i<BUFLEN;i%2B%2B)
++++buf[i]=0;

++if(argc<2)
++{
++++printf("usage:+%25s+<int>\n",+argv[0]);
++++return+1;
++}
++n+=+atoi(argv[1]);
++i+=+0;
++printf("n:+%25d\n",+n);

++for(i=0;+i<4;+i%2B%2B)
++{
++++cn+=+(n>>4*i)+&+0xF;
++++c++=+(cn>15)+?+hexmap[16]+:+hexmap[cn];
++++printf("cn:+%25d,+c:+%25c\n",+cn,+c);

++++buf[3-i]+=+(cn>15)+?+hexmap[16]+:+hexmap[cn];
++}
++buf[4]+=+'\0';+//+null+terminate+it

++printf("buf:+%25s\n",+buf);
++return+0;
}|code-block|syntax|javascript|887075|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's a crude way of doing it. If we can't trust the encoding of ascii values to be consecutive, we just create a mapping of hex values in char. Probably can be optimized, tidied up, and made prettier. Also assumes we only look at capture the last 32bits == 4 hex chars.

<pre><code>#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

#define BUFLEN 5

int main(int argc, char* argv[])
{
 int n, i, cn;
 char c, buf[5];
 char hexmap[17] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','.'};

 for(i=0;i&lt;BUFLEN;i++)
 buf[i]=0;

 if(argc&lt;2)
 {
 printf("usage: %s &lt;int&gt;\n", argv[0]);
 return 1;
 }
 n = atoi(argv[1]);
 i = 0;
 printf("n: %d\n", n);

 for(i=0; i&lt;4; i++)
 {
 cn = (n&gt;&gt;4*i) &amp; 0xF;
 c = (cn&gt;15) ? hexmap[16] : hexmap[cn];
 printf("cn: %d, c: %c\n", cn, c);

 buf[3-i] = (cn&gt;15) ? hexmap[16] : hexmap[cn];
 }
 buf[4] = '\0'; // null terminate it

 printf("buf: %s\n", buf);
 return 0;
}
</code></pre>

blocks|key|1102019|text|这个函数的作用就像一个护身符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1102020|void+WORD2WBYTE(BYTE+WBYTE[2],+WORD+Value)+{+
++++BYTE+tmpByte[2];+
++++//+Converts+a+value+from+word+to+word+byte+----
++++memcpy(tmpByte,+(BYTE*)+&+Value,+2);+
++++WBYTE[1]+=+tmpByte[0];+
++++WBYTE[0]+=+tmpByte[1];+
}+|code-block|syntax|javascript|1102021|总结以下内容：|1102022|typedef+unsigned+char+++BYTE;+
typedef+unsigned+short++WORD;|1102023|使用示例：|1102024|我们想要实现这一点：|1102025|integer+=+92
byte+array+in+hex:
a[0]+=+0x00;
a[1]+=+0x5c;

unsigned+char+_byteHex[2];
WORD2WBYTE(_byteHex,+92);|1102026|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This function works like a charm. 

<pre><code>void WORD2WBYTE(BYTE WBYTE[2], WORD Value) { 
 BYTE tmpByte[2]; 
 // Converts a value from word to word byte ----
 memcpy(tmpByte, (BYTE*) &amp; Value, 2); 
 WBYTE[1] = tmpByte[0]; 
 WBYTE[0] = tmpByte[1]; 
} 
</code></pre>

asumming the following: 

<pre><code>typedef unsigned char BYTE; 
typedef unsigned short WORD;
</code></pre>

Example of use: 

we want to achieve this: 

<pre><code>integer = 92
byte array in hex:
a[0] = 0x00;
a[1] = 0x5c;

unsigned char _byteHex[2];
WORD2WBYTE(_byteHex, 92);
</code></pre>

blocks|key|887280|text|您可以使用它，它是简单和容易转换|type|unstyled|depth|inlineStyleRanges|entityRanges|data|887281|typedef+union+{
++++struct+hex{
++++++++++++unsigned++char+a;
++++++++++++unsigned++char+b;

++++}hex_da;
++++short+int+dec_val;
}hex2dec;

hex2dec+value;
value.dec_val=10;|code-block|syntax|javascript|887282|现在十六进制值存储在hex_da结构中，访问它以供进一步使用。|887283|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|$]]

you can use this it is simple and easy to convert

<pre><code>typedef union {
 struct hex{
 unsigned char a;
 unsigned char b;

 }hex_da;
 short int dec_val;
}hex2dec;

hex2dec value;
value.dec_val=10;
</code></pre>

Now hex value is stored in hex_da structure access it for further use.

blocks|key|887285|text|使用Vicky上面的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|887286|typedef+unsigned++++long++++ulong;
typedef+unsigned++++char++++uchar;

#define+TO_HEX(i)+++(i+<=+9+?+'0'+%2B+i+:+'A'+-+10+%2B+i)
#define+max_strhex++(sizeof(ulong)*2)

public+uchar
*mStrhex(uchar+*p,+ulong+w,+ulong+n)
{
++++ulong+i+=+0xF;++++++++++++++++++++++++++++++++++//+index
++++ulong+mask++=+i+<<+(((sizeof(ulong)*2)-1)*4);+++//+max+mask+(32+bit+ulong+mask+=+0xF0000000,+16+bit+ulong+mask+=+0xF000)
++++ulong+shift+=+(w*4);++++++++++++++++++++++++++++//+set+up+shift+to+isolate+the+highest+nibble
++++if(!w+%7C%7C+w+>+max_strhex)++++++++++++++++++++++++//+no+bold+params
++++++++return+p;+++++++++++++++++++++++++++++++++++//+do+nothing+for+the+rebel
++++mask++=+mask+>>+(max_strhex-w)*4;+++++++++++++++//+setup+mask+to+extract+hex+nibbles
++++for(i+=+0;+i+<+w;+i%2B%2B){+++++++++++++++++++++++++//+loop+and+add+w+nibbles
++++++++shift+=+shift+-+4;++++++++++++++++++++++++++//+hint:+start+mask+for+four+bit+hex+is+0xF000,+shift+is+32,+mask+>>+32+is+0x0000,+mask+>>+28+is+0x000F.
++++++++*p%2B%2B+=+TO_HEX(((n+&+mask)+>>+shift));+++++++//+isolate+digit+and+make+hex
++++++++mask+=+mask+>>+4;+++++++++++++++++++++++++++//
++++++++*p+=+'\0';++++++++++++++++++++++++++++++++++//+be+nice+to+silly+people
++++}+++++++++++++++++++++++++++++++++++++++++++++++//
++++return+p;+++++++++++++++++++++++++++++++++++++++//+point+to+null,+allow+concatenation
}|code-block|syntax|javascript|887287|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|$]]

Using Vicky's answer above

<pre><code>typedef unsigned long ulong;
typedef unsigned char uchar;

#define TO_HEX(i) (i &lt;= 9 ? '0' + i : 'A' - 10 + i)
#define max_strhex (sizeof(ulong)*2)

public uchar
*mStrhex(uchar *p, ulong w, ulong n)
{
 ulong i = 0xF; // index
 ulong mask = i &lt;&lt; (((sizeof(ulong)*2)-1)*4); // max mask (32 bit ulong mask = 0xF0000000, 16 bit ulong mask = 0xF000)
 ulong shift = (w*4); // set up shift to isolate the highest nibble
 if(!w || w &gt; max_strhex) // no bold params
 return p; // do nothing for the rebel
 mask = mask &gt;&gt; (max_strhex-w)*4; // setup mask to extract hex nibbles
 for(i = 0; i &lt; w; i++){ // loop and add w nibbles
 shift = shift - 4; // hint: start mask for four bit hex is 0xF000, shift is 32, mask &gt;&gt; 32 is 0x0000, mask &gt;&gt; 28 is 0x000F.
 *p++ = TO_HEX(((n &amp; mask) &gt;&gt; shift)); // isolate digit and make hex
 mask = mask &gt;&gt; 4; //
 *p = '\0'; // be nice to silly people
 } //
 return p; // point to null, allow concatenation
}
</code></pre>

blocks|key|887332|text|对于十六进制的动态固定长度|type|unstyled|depth|inlineStyleRanges|entityRanges|data|887333|string+makeFixedLengthHex(const+int+i,+const+int+length)
{
++++std::ostringstream+ostr;
++++std::stringstream+stream;
++++stream+<<+std::hex+<<+i;
++++ostr+<<+std::setfill('0')+<<+std::setw(length)+<<+stream.str();
++++return+ostr.str();
}|code-block|syntax|javascript|887334|但是否定的，你必须自己处理它。|887335|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|$]]

For dynamic fixed length of hex

<pre><code>string makeFixedLengthHex(const int i, const int length)
{
 std::ostringstream ostr;
 std::stringstream stream;
 stream &lt;&lt; std::hex &lt;&lt; i;
 ostr &lt;&lt; std::setfill('0') &lt;&lt; std::setw(length) &lt;&lt; stream.str();
 return ostr.str();
}
</code></pre>

But negative you have to handle it yourself.

I need to convert an int to a 2 byte hex value to store in a char array, in C. How can I do this?

Converting an int to a 2 byte hex value in C

编译器

我需要将一个int转换成一个2字节的十六进制值，然后用C存储在一个char数组中。我该怎么做呢？

问在C中将int转换为2字节的十六进制值
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中将int转换为2字节的十六进制值EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中将int转换为2字节的十六进制值
EN