如何在C中手动将十进制值转换为十六进制字符串？

n、 b.我知道这个问题以前在StackOverflow上以各种不同的方式和情况被问过，但我寻求的答案对我的具体案例没有太大帮助。因此，虽然这最初看起来像是一个问题的复制品，例如给出的答案，但它们是准确的，但对我来说没有用处

我的问题是如何手动将十进制整数转换为十六进制字符串。我知道stdlib.h和printf有一些技巧，但这是一项大学任务，我需要手动完成（教授的命令）。然而，我们被允许寻求帮助

使用古老的“除以16并将余数转换为十六进制并反转值”方法来获取十六进制字符串，但我的代码中肯定有一个很大的错误，因为它不会返回给我，例如十进制值“188”的“BC”

假设算法永远不需要为大于256（或FF）的小数找到十六进制值。虽然参数的传递可能不是最优的或理想的，但这是我们被告知要使用的（尽管我可以修改getHexValue函数，因为我自己编写了这个函数）

这就是我到目前为止所做的：

/* Function to get the hex character for a decimal (value) between
 * 0 and 16.  Invalid values are returned as -1.
 */
char getHexValue(int value) 
{
   if (value < 0) return -1;
   if (value > 16) return -1;
   if (value <= 9) return (char)value;
   value -= 10;
   return (char)('A' + value);
}


/* Function asciiToHexadecimal() converts a given character (inputChar) to
 * its hexadecimal (base 16) equivalent, stored as a string of
 * hexadecimal digits in hexString. This function will be used in menu
 * option 1.
 */
void asciiToHexadecimal(char inputChar, char *hexString)
{
   int i = 0;
   int remainders[2];
   int result = (int)inputChar;
   while (result) {
      remainders[i++] = result % 16;
      result /= (int)16;
   }
   int j = 0;
   for (i = 2; i >= 0; --i) {
      char c = getHexValue(remainders[i]);
      *(hexString + (j++)) = c;
   }
}

---

（此代码剪切坑中的所有内容都可以正常工作，除了

hexString

）

您非常接近-进行以下两个小更改，它将足以让您完成它：

（1） 更改：

致：

（inputChar被视为有符号的，这会产生不希望的结果，

%

）

以下几点提示：

• 对于无效输入，让getHexValue返回

  '？'

  而不是

  -1

  （使调试更容易）

• 编写用于调试的测试线束，例如

  int main(void)
  {
      char hexString[256];
  
      asciiToHexadecimal(166, hexString);
  
      printf("hexString = %s = %#x %#x %#x ...\n", hexString, hexString[0], hexString[1], hexString[2]);
  
      return 0;
  }
  

hexString

分配的一个字节太小，不能作为C字符串--您忘记为ASCII NUL

'\0'

字符留出空间。如果使用

%c

格式说明符打印

hexString

，或者使用

memcpy（3）

构建更大的字符串，这可能没问题，但是您的

printf（）

调用将

hexString

视为字符串

一般来说，当你看到

char *foo = malloc(N);

call，害怕——C习惯用法是

char *foo = malloc(N+1);

---

那

+1

是你向他人（和你自己，两个月后）发出的信号，你已经为NUL留下了空间。如果你在另一次计算中隐藏了

+1

，你就失去了一个机会去记忆一个模式，这个模式可以在每次阅读代码时捕捉到这些bug。（老实说，就在两天前，我通过SO上的这个精确模式发现了其中的一个：）

是纯十六进制的目标，还是该函数可以参数化。如果它被限制为十六进制，为什么不利用一个十六进制数字正好编码四位的事实呢

我会这样做：

#include <stdlib.h>

#include <limits.h> /* implementation's CHAR_BIT */

#define INT_HEXSTRING_LENGTH (sizeof(int)*CHAR_BIT/4)
/* We define this helper array in case we run on an architecture
   with some crude, discontinous charset -- THEY EXIST! */
static char const HEXDIGITS[0x10] = 
    {'0', '1', '2', '3', '4', '5', '6', '7',
     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
void int_to_hexstring(int value, char result[INT_HEXSTRING_LENGTH+1])
{
    int i;
    result[INT_HEXSTRING_LENGTH] = '\0';

    for(i=INT_HEXSTRING_LENGTH-1; value; i--, value >>= 4) {
        int d  = value & 0xf;
        result[i] = HEXDIGITS[d];
    }

    for(;i>=0;i--){ result[i] = '0'; }
}
int main(int argc, char *argv[])
{
    char buf[INT_HEXSTRING_LENGTH+1];

    if(argc < 2)
        return -1;

    int_to_hexstring(atoi(argv[1]), buf);
    puts(buf);
    putchar('\n');

    return 0;
}

#包括
#包含/*实现的字符位*/
#定义INT_hextstring_长度（sizeof（INT）*字符位/4）
/*如果我们在一个体系结构上运行，我们将定义这个helper数组
带着一些粗糙的、不连续的字符——它们是存在的*/
静态字符常量十六进制数字[0x10]=
{'0', '1', '2', '3', '4', '5', '6', '7',
‘8’、‘9’、‘a’、‘b’、‘c’、‘d’、‘e’、‘f’}；
void int_to_hextstring（int值，字符结果[int_hextstring_LENGTH+1]）
{
int i；
结果[INT_hextstring_LENGTH]='\0'；
对于（i=INT\u hextstring\u LENGTH-1；值；i--，值>>=4）{
int d=值&0xf；
结果[i]=六位数[d]；
}
对于（；i>=0；i--）{result[i]='0'；}
}
int main（int argc，char*argv[]）
{
字符buf[INT_hextstring_LENGTH+1]；
如果（argc<2）
返回-1；
int_to_hexstring（atoi（argv[1]），buf）；
put（buf）；
putchar（'\n'）；
返回0；
}

我制作了一个库来进行十六进制/十进制转换，而不使用

stdio.h

。使用非常简单：

char*dechex（int-dec）；

这将使用

calloc（）

返回指向十六进制字符串的指针，这样可以优化使用的内存量，所以不要忘记使用

free（）

这里是github上的链接：

#include
字符*inttohex（int）；
main（）
{
int i；
char*c；
printf（“输入编号。\n”）；
scanf（“%d”、&i）；
c=inttohex（i）；
printf（“c=%s”，c）；
}
字符*inttohex（inti）
{
int l1，l2，j=0，n；
静态字符a[100]，t；
而（i！=0）
{
l1=i%16；
如果（l1>10）
{
a[j]=l1-10+'a'；
}
其他的
sprintf（a+j，“%d”，l1）；
i=i/16；
j++；
}
n=strlen（a）；
对于（i=0；i在其他好答案的补充中…）

如果这些十六进制或十进制字符串所表示的数字很大（例如，数百位数字），那么它们将不适合
long
（或您的C实现提供的任何最大整数类型）。然后您需要。我建议不要编写您自己的实现（要制作一个高效的实现很困难），但是使用一个现有的问题，如
+1，来解决一个表现良好的问题，并在寻求帮助之前对作业进行大量的努力-我希望更多的

家庭作业问题具有类似的质量…而且对输出的思考也非常出色！”输出结果如\377“-

\377

是

（char）-1

。您的

getHexValue

例程返回一个负整数作为错误代码，但键入该例程以返回一个

char

，然后您从不检查错误代码，这是非常糟糕的。代码中没有任何强制转换是必要的。不必要的强制转换是一个坏主意，因为它们可以隐藏错误。感谢您的回答，非常感谢，但是我不能更改十六进制的签名。：）这太棒了，谢谢你花时间帮我找到这个bug。我想我明白你的意思了，我会做出适当的修改。至于单元测试，我非常喜欢C#和Ruby/Rails中的单元测试，我的大部分经验都来自于这两种语言，但我不知道如何围绕C代码来包装测试框架

void asciiToHexadecimal(unsigned char inputChar, char *hexString)

int main(void)
{
    char hexString[256];

    asciiToHexadecimal(166, hexString);

    printf("hexString = %s = %#x %#x %#x ...\n", hexString, hexString[0], hexString[1], hexString[2]);

    return 0;
}

char getHexValue(int value)
{
   if (value < 0) return -1;
   if (value > 16) return -1;
   if (value <= 9) return (char)value;
   value -= 10;
   return (char)('A' + value);
}

char* binaryString = (char*) malloc(8);
char* hexString = (char*) malloc(2);
asciiToBinary(*(asciiString + i), binaryString);
asciiToHexadecimal(*(asciiString + i), hexString);
printf("%6c%13s%9s\n", *(asciiString + i), binaryString, hexString);

char *foo = malloc(N);

char *foo = malloc(N+1);

#include <stdlib.h>

#include <limits.h> /* implementation's CHAR_BIT */

#define INT_HEXSTRING_LENGTH (sizeof(int)*CHAR_BIT/4)
/* We define this helper array in case we run on an architecture
   with some crude, discontinous charset -- THEY EXIST! */
static char const HEXDIGITS[0x10] = 
    {'0', '1', '2', '3', '4', '5', '6', '7',
     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
void int_to_hexstring(int value, char result[INT_HEXSTRING_LENGTH+1])
{
    int i;
    result[INT_HEXSTRING_LENGTH] = '\0';

    for(i=INT_HEXSTRING_LENGTH-1; value; i--, value >>= 4) {
        int d  = value & 0xf;
        result[i] = HEXDIGITS[d];
    }

    for(;i>=0;i--){ result[i] = '0'; }
}
int main(int argc, char *argv[])
{
    char buf[INT_HEXSTRING_LENGTH+1];

    if(argc < 2)
        return -1;

    int_to_hexstring(atoi(argv[1]), buf);
    puts(buf);
    putchar('\n');

    return 0;
}

#include<stdio.h>

char* inttohex(int);
main()
{
    int i;
    char *c;
    printf("Enter the no.\n");
    scanf("%d",&i);
    c=inttohex(i);
    printf("c=%s",c);
}

char* inttohex(int i)
{
    int l1,l2,j=0,n;
    static char a[100],t;

    while(i!=0)
    {
    l1=i%16;
    if(l1>10)
    {
        a[j]=l1-10+'A';
    }

    else
        sprintf(a+j,"%d",l1);

    i=i/16;
    j++;
    }
    n=strlen(a);
    for(i=0;i<n/2;i++)
    {
        t=a[i];
        a[i]=a[n-i-1];
        a[n-i-1]=t;
    }

    //printf("string:%s",a);
    return a;
    //
}