在C语言中将int转换为2字节十六进制值

我需要将一个int转换成一个2字节的十六进制值，以存储在一个字符数组中，用C语言。我如何才能做到这一点

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

---

您可能需要查看

sprintf（）

文档。请注意，此代码不是很安全。如果

x

大于

0xFFFF

，则最后一个字符串将超过4个字符且不适合。为了使其更安全，请查看

snprintf（）

或者尝试以下方法：

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

void IntToHex（int值，字符*缓冲区）{
int a=值&16；
intb=（值>>4）和16；
缓冲区[0]=（a假设int为32位

最简单的方法：只需使用sprintf（）

现在使用hexval[0]到hexval[3]；如果要将其用作以null结尾的字符串，请添加
hexval[4]=0；
如果允许使用库函数：

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

if (x <= 0xFFFF)
{
    sprintf(&res[0], "%04x", x);
}

intx=某个整数；
char res[5]；/*两个字节的十六进制=4个字符，加上空终止符*/
如果（x而不是
sprintf
，我建议使用
snprintf

#include <stdio.h>

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

    printf("%s\n",output);
    return 0;
}

#包括
int main（）
{
字符输出[5]；
snprintf（输出，5，“%04x”，255）；
printf（“%s\n”，输出）；
返回0；
}

它安全得多，几乎在每个编译器中都可以使用。
这些答案中的大多数都很好，我只想补充一点：您可以使用sizeof安全地保留正确的字节数。每个字节最多可以占用两个十六进制数（255->ff）在这个例子中，我为'0x'前缀添加了两个字符，为后面的NUL添加了一个字符

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

input\u int
是您要转换的数字。
hex16
将具有最低有效2字节的
input\u int
。如果您要将其打印到控制台，请使用
%x
作为格式说明符，而不是
%d
，它将以十六进制格式打印。
通常我建议使用
spri其他人推荐的基于ntf
的解决方案。但当我编写一个必须将数十亿项转换为十六进制的工具时，sprintf太慢了。对于该应用程序，我使用了256元素数组，它将字节映射为字符串

这是一个不完整的转换1字节的解决方案，不要忘记添加边界检查，并确保数组是静态的或全局的，为每次检查重新创建它会降低性能

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

这是一种粗略的方法。如果我们不能相信ascii值的编码是连续的，我们只需在字符中创建十六进制值的映射。可能可以优化、整理并使其更漂亮。还假设我们只查看捕获最后32位==4个十六进制字符

#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++)
    buf[i]=0;

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

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

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

  printf("buf: %s\n", buf);
  return 0;
}

#包括
#包括
#定义BUFLEN 5
int main（int argc，char*argv[]）
{
int n，i，cn；
字符c，buf[5]；
字符hexmap[17]={0'、'1'、'2'、'3'、'4'、'5'、'6'、'7'、'8'、'9'、'A'、'B'、'C'、'D'、'E'、'F'、'.}；
对于（i=0；i4*i）&0xF；
c=（cn>15）？hexmap[16]：hexmap[cn]；
printf（“cn:%d，c:%c\n”，cn，c）；
buf[3-i]=（cn>15）？hexmap[16]：hexmap[cn]；
}
buf[4]='\0'；//null终止它
printf（“基本单位：%s\n”，基本单位）；
返回0；
}
找到了一种我测试过的快速方法，并且效果良好

int value = 11;

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

printf("%x%x", array[0], array[1]);

结果是：

000B

它是十六进制的11。
这个函数就像一个符咒

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

a使用以下命令：


typedef unsigned char   BYTE; 
typedef unsigned short  WORD;

使用示例：

我们希望做到这一点：

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

unsigned char _byteHex[2];
WORD2WBYTE(_byteHex, 92);

void intToHex（int intnumber，char*txt）
{    
无符号字符_s4='0'；
字符i=4；
//intnumber=0xffff；
做{
我--；
_s4=（无符号字符）（（intnumber>>i*4）和0x000f）；
如果（_s4您可以使用此功能，则它非常简单且易于转换

typedef union {
    struct hex{
            unsigned  char a;
            unsigned  char b;

    }hex_da;
    short int dec_val;
}hex2dec;

hex2dec value;
value.dec_val=10;

现在十六进制值存储在hex_da结构中，请访问它以供进一步使用。
使用上面Vicky的答案

typedef unsigned    long    ulong;
typedef unsigned    char    uchar;

#define TO_HEX(i)   (i <= 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 << (((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 > 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++){                         // 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++ = 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
}

typedef无符号长ulong；
typedef无符号字符；
#定义为_HEX（i）（i>（max_strhex-w）*4；//设置掩码以提取十六进制半字节
对于（i=0；i>32为0x0000，掩码>>28为0x000F。
*p++=TO_HEX（（（n&mask）>>shift））；//隔离数字并生成十六进制
掩码=掩码>>4//
*p='\0'；//善待愚蠢的人
}                                               //
返回p；//指向null，允许连接
}
用于十六进制的动态固定长度

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

字符串makeFixedLengthHex（常量int i，常量int length）
{
标准：ostringstream ostr；
std:：stringstream；
流整型数据类型为32位，而2字节十六进制值为8位。如果整型大于255，则它将不适合十六进制值（它将溢出）。你的意思是有符号/无符号字符而不是int吗？@wez:int不一定是32位。但你的问题很好，他需要注意溢出。这个问题看起来像是家庭作业……这是真的吗？如果是，请添加“家庭作业”标签。@Denilson:但是，@MikeU，请（一如既往）遵循，陈述任何特殊限制，展示您迄今为止所做的尝试，并询问具体是什么让您感到困惑。从看到其他人的答案来看，他们似乎在解释“双字节十六进制值”这意味着两个Nybles，每个由一个字节的十六进制字符表示。我认为这意味着两个字节的数据，每个由两个十六进制字符表示。你需要澄清你的意思！感谢@Vicky的答案。使用它在下面的答案中构建函数。这段代码假设字母A到F占据连续的代码点。这不能保证通过C语言。你能想到任何没有连续字母的实现或编码吗？这仍然是一个很好的答案，应该包括Baudot代码和UPP代码。当0xFFvoid 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+48;
        else
            _s4=_s4+55;

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

intToHex(65534,text);
USART_Write_Text(text);
....

typedef union {
    struct hex{
            unsigned  char a;
            unsigned  char b;

    }hex_da;
    short int dec_val;
}hex2dec;

hex2dec value;
value.dec_val=10;

typedef unsigned    long    ulong;
typedef unsigned    char    uchar;

#define TO_HEX(i)   (i <= 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 << (((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 > 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++){                         // 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++ = 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
}

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