C语言十进制原码转换十六进制函数接口

以下是一个将十进制原码转换为十六进制的C语言函数接口：

void decToHex(int dec, char hex[]);

其中，`dec`是需要转换的十进制数，`hex`是存储转换结果的字符数组。函数实现如下：

void decToHex(int dec, char hex[]) {
  int i = 0;
  while (dec > 0) {
    int rem = dec % 16;
    if (rem < 10) {
      hex[i] = rem + 48;
    } else {
      hex[i] = rem + 55;
    }
    i++;
    dec /= 16;
  }
  hex[i] = '\0';
  strrev(hex);
}

使用方法如下：

int main() {
  int dec = 255;
  char hex[10];
  decToHex(dec, hex);
  printf("0x%s", hex);
  return 0;
}

输出结果为：

0xFF

相关问题

C语言十进制原码转十六进制的函数接口

以下是将十进制原码转换为十六进制的C语言函数接口：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *dec_to_hex(int decimal_num) {
  int is_negative = 0;
  char *hex_str = (char *)malloc(sizeof(char) * 9);
  memset(hex_str, 0, sizeof(char) * 9);

  // 判断数字是否为负数
  if (decimal_num < 0) {
    is_negative = 1;
    decimal_num = abs(decimal_num);
  }

  // 将数字转换为十六进制
  int index = 0;
  while (decimal_num > 0) {
    int remainder = decimal_num % 16;
    if (remainder < 10) {
      hex_str[index++] = remainder + '0';
    } else {
      hex_str[index++] = remainder - 10 + 'A';
    }
    decimal_num /= 16;
  }

  // 如果是负数，需要将十六进制字符串取反后再加1
  if (is_negative) {
    for (int i = 0; i < strlen(hex_str); i++) {
      if (hex_str[i] >= '0' && hex_str[i] <= '9') {
        hex_str[i] = 'F' - (hex_str[i] - '0') + 1;
      } else if (hex_str[i] >= 'A' && hex_str[i] <= 'F') {
        hex_str[i] = 'F' - (hex_str[i] - 'A') + 1;
      }
    }
    hex_str = add_one(hex_str);
  }

  // 反转字符串
  int len = strlen(hex_str);
  for (int i = 0; i < len / 2; i++) {
    char tmp = hex_str[i];
    hex_str[i] = hex_str[len - i - 1];
    hex_str[len - i - 1] = tmp;
  }

  return hex_str;
}

char *add_one(char *hex_str) {
  int carry = 1;
  int len = strlen(hex_str);
  char *result = (char *)malloc(sizeof(char) * (len + 1));
  memset(result, 0, sizeof(char) * (len + 1));

  for (int i = len - 1; i >= 0; i--) {
    char digit = hex_str[i];
    if (digit >= '0' && digit <= '8' && carry == 1) {
      result[i] = digit + 1;
      carry = 0;
    } else if (digit == '9' && carry == 1) {
      result[i] = 'A';
      carry = 0;
    } else if (digit == 'A' && carry == 1) {
      result[i] = 'B';
      carry = 0;
    } else if (digit == 'B' && carry == 1) {
      result[i] = 'C';
      carry = 0;
    } else if (digit == 'C' && carry == 1) {
      result[i] = 'D';
      carry = 0;
    } else if (digit == 'D' && carry == 1) {
      result[i] = 'E';
      carry = 0;
    } else if (digit == 'E' && carry == 1) {
      result[i] = 'F';
      carry = 0;
    } else {
      result[i] = digit;
    }
  }
  if (carry == 1) {
    result[0] = '1';
  }

  return result;
}

调用方式：

#include <stdio.h>

int main() {
  // 将十进制数 -10 转换为十六进制
  char *hex_str = dec_to_hex(-10);
  printf("%s\n", hex_str);  // 输出结果为 FFFFFFF6

  free(hex_str);
  return 0;
}

这个函数可以将任意十进制数字转换为十六进制，包括负数。当输入为负数时，会将其转换为原码后再转换为十六进制。需要注意的是，返回的十六进制字符串需要手动释放。

C语言十进制负数原码转换十六进制函数接口

以下是一个将十进制负数原码转换为十六进制的C语言函数接口：

void decToHex(int num, char* hex);

其中，`num`为输入的负数原码的十进制表示，`hex`为转换后的十六进制字符串。在函数中，需要先将负数原码转换为补码表示，然后再进行十六进制转换。

以下是该函数的具体实现：

void decToHex(int num, char* hex) {
    int i = 0;
    int mask = 15; // 二进制掩码为1111
    int temp = 0;
    // 将负数原码转换为补码
    num = ~num + 1;
    // 逐位进行转换
    while (num != 0) {
        temp = num & mask;
        if (temp < 10) {
            hex[i] = temp + '0';
        } else {
            hex[i] = temp - 10 + 'A';
        }
        num = num >> 4; // 每次将num右移4位
        i++;
    }
    // 添加负号
    hex[i] = '-';
    i++;
    // 添加结束符
    hex[i] = '\0';
    // 反转字符串
    int len = strlen(hex);
    for (int j = 0; j < len / 2; j++) {
        char temp = hex[j];
        hex[j] = hex[len - j - 1];
        hex[len - j - 1] = temp;
    }
}

使用该函数的示例代码如下：

int main() {
    int num = -123;
    char hex[20];
    decToHex(num, hex);
    printf("%d的十六进制表示为：%s\n", num, hex);
    return 0;
}

输出结果为：`-7B`，即 `-123`的十六进制表示为`-7B`。