C语言中将字符数组转换成十六进制字符串

动态申请内存版

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

// 定义一个函数，用于将一个字符转化为十六进制表示
char* char_to_hex(char c) {
    // 创建一个长度为 3 的字符串，用于存储结果
    char* hex = (char*)malloc(3 * sizeof(char));
    // 使用 sprintf 函数，将字符 c 的 ASCII 码转化为十六进制，并存储在 hex 中
    sprintf(hex, "%02x", c);
    // 返回 hex
    return hex;
}

// 定义一个函数，用于将一个字符数组转化为十六进制字符串
char* array_to_hex(char* array, int size) {
    // 创建一个长度为 2 * size + 1 的字符串，用于存储结果
    char* hex = (char*)malloc((2 * size + 1) * sizeof(char));
    // 初始化 hex 为空字符串
    hex[0] = '\0';
    // 遍历字符数组中的每个元素
    for (int i = 0; i < size; i++) {
        // 调用 char_to_hex 函数，将当前元素转化为十六进制
        char* temp = char_to_hex(array[i]);
        // 将转化后的十六进制字符串追加到 hex 中
        strcat(hex, temp);
        // 如果不是最后一个元素，还要在 hex 中加入一个空格
        if (i < size - 1) {
            strcat(hex, " ");
        }
        // 释放 temp 的内存
        free(temp);
    }
    // 返回 hex
    return hex;
}

// 定义一个主函数，用于测试
int main() {
    // 创建一个字符数组，用于存储输入
    char array[] = {0x55, 0xaa};
    // 获取字符数组的长度
    int size = sizeof(array) / sizeof(array[0]);
    // 调用 array_to_hex 函数，将字符数组转化为十六进制字符串
    char* hex = array_to_hex(array, size);
    // 打印结果
    printf("The hexadecimal string is: %s\n", hex);
    // 释放 hex 的内存
    free(hex);
    // 返回 0
    return 0;
}

静态内存版

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

// 定义一个函数，用于将一个 unsigned char 转化为十六进制表示，并存储在一个给定的字符串中
void char_to_hex(unsigned char c, char* hex) {
    // 定义一个字符数组，用于存储十六进制的数字
    char digits[] = "0123456789abcdef";
    // 使用位运算，将 unsigned char 的高四位和低四位分别提取出来
    int high = (c >> 4) & 0x0f;
    int low = c & 0x0f;
    // 使用字符数组，将高四位和低四位分别转化为对应的十六进制字符，并存储在 hex 中
    hex[0] = digits[high];
    hex[1] = digits[low];
    // 在 hex 的末尾加上一个空字符，表示字符串的结束
    hex[2] = '\0';
}

// 定义一个函数，用于将一个 unsigned char 数组转化为十六进制字符串，并存储在一个给定的字符串中
void array_to_hex(unsigned char* array, int size, char* hex) {
    // 初始化 hex 为空字符串
    hex[0] = '\0';
    // 遍历 unsigned char 数组中的每个元素
    for (int i = 0; i < size; i++) {
        // 创建一个长度为 3 的字符串，用于存储当前元素的十六进制表示
        char temp[3];
        // 调用 char_to_hex 函数，将当前元素转化为十六进制，并存储在 temp 中
        char_to_hex(array[i], temp);
        // 将转化后的十六进制字符串追加到 hex 中
        strcat(hex, temp);
        // 如果不是最后一个元素，还要在 hex 中加入一个空格
        if (i < size - 1) {
            strcat(hex, " ");
        }
    }
}

// 定义一个主函数，用于测试
int main() {
    // 创建一个 unsigned char 数组，用于存储输入
    unsigned char array[] = {0x55, 0xaa};
    // 获取 unsigned char 数组的长度
    int size = sizeof(array) / sizeof(array[0]);
    // 创建一个长度为 2 * size + 1 的字符串，用于存储转化后的十六进制字符串
    char hex[2 * size + 1];
    // 调用 array_to_hex 函数，将 unsigned char 数组转化为十六进制字符串，并存储在 hex 中
    array_to_hex(array, size, hex);
    // 打印结果
    printf("The hexadecimal string is: %s\n", hex);
    // 返回 0
    return 0;
}