【无标题】

原创于 2024-12-17 21:13:36 发布 · 1.5k 阅读

CC 4.0 BY-SA版权

文章标签：

完成下面任务（29分）
1 在 Ubuntu 或 openEuler 中完成任务（推荐openEuler）
2 简述 GM/T0009 4种数据转换的功能，根据你的理解，每种转换功能给出至少一个例子（8分）
3 参考课程代码sdfproject，基于一个模块utils.c，utils.h使用四个函数分别实现4种数据转换的功能（12分）
4 src中在testsdf.c中编写main函数测试四个转换功能。（6分）

字节数组到十六进制字符串的转换
功能：将字节数组（二进制数据）转换为十六进制字符串。

例子：

输入：{0x4a, 0x5b, 0x6c}

输出：“4a5b6c”

十六进制字符串到字节数组的转换
功能：将十六进制字符串转换为字节数组（二进制数据）。

例子：

输入：“4a5b6c”

输出：{0x4a, 0x5b, 0x6c}

字节数组到 Base64 字符串的转换
功能：将字节数组（二进制数据）转换为 Base64 编码的字符串。

例子：

输入：{0x4a, 0x5b, 0x6c}

输出：“Smtj”

Base64 字符串到字节数组的转换
功能：将 Base64 编码的字符串转换为字节数组（二进制数据）。

例子：

输入：“Smtj”

输出：{0x4a, 0x5b, 0x6c}

基于 utils.c 和 utils.h 实现 4 种数据转换功能
utils.h 文件

#ifndef UTILS_H
#define UTILS_H

#include <stdint.h>

// 字节数组到十六进制字符串的转换
void bytes_to_hex(const uint8_t *input, size_t input_len, char *output);

// 十六进制字符串到字节数组的转换
int hex_to_bytes(const char *input, uint8_t *output, size_t *output_len);

// 字节数组到 Base64 字符串的转换
void bytes_to_base64(const uint8_t *input, size_t input_len, char *output);

// Base64 字符串到字节数组的转换
int base64_to_bytes(const char *input, uint8_t *output, size_t *output_len);

#endif // UTILS_H
utils.c 文件

#include “utils.h”
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>

// 字节数组到十六进制字符串的转换
void bytes_to_hex(const uint8_t *input, size_t input_len, char *output) {
const char *hex_chars = “0123456789abcdef”;
for (size_t i = 0; i < input_len; i++) {
output[i * 2] = hex_chars[(input[i] >> 4) & 0x0F];
output[i * 2 + 1] = hex_chars[input[i] & 0x0F];
}
output[input_len * 2] = ‘\0’;
}

// 十六进制字符串到字节数组的转换
int hex_to_bytes(const char *input, uint8_t *output, size_t *output_len) {
size_t len = strlen(input);
if (len % 2 != 0) {
return -1; // 输入长度必须是偶数
}
*output_len = len / 2;
for (size_t i = 0; i < *output_len; i++) {
sscanf(&input[i * 2], “%2hhx”, &output[i]);
}
return 0;
}

// 字节数组到 Base64 字符串的转换
void bytes_to_base64(const uint8_t *input, size_t input_len, char *output) {
const char *base64_chars = “ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”;
size_t i = 0, j = 0;
uint8_t char_array_3[3], char_array_4[4];

while (input_len--) {
    char_array_3[i++] = *(input++);
    if (i == 3) {
        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (i = 0; i < 4; i++) {
            output[j++] = base64_chars[char_array_4[i]];
        }
        i = 0;
    }
}

if (i) {
    for (size_t k = i; k < 3; k++) {
        char_array_3[k] = '\0';
    }

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for (size_t k = 0; k < i + 1; k++) {
        output[j++] = base64_chars[char_array_4[k]];
    }

    while (i++ < 3) {
        output[j++] = '=';
    }
}

output[j] = '\0';

}

// Base64 字符串到字节数组的转换
int base64_to_bytes(const char *input, uint8_t *output, size_t *output_len) {
const char *base64_chars = “ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”;
size_t len = strlen(input);
if (len % 4 != 0) {
return -1; // 输入长度必须是 4 的倍数
}

size_t i = 0, j = 0;
uint8_t char_array_4[4], char_array_3[3];

while (len-- && input[i] != '=') {
    char_array_4[i++] = strchr(base64_chars, input[i]) - base64_chars;
    if (i == 4) {
        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (i = 0; i < 3; i++) {
            output[j++] = char_array_3[i];
        }
        i = 0;
    }
}

if (i) {
    for (size_t k = i; k < 4; k++) {
        char_array_4[k] = 0;
    }

    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

    for (size_t k = 0; k < i - 1; k++) {
        output[j++] = char_array_3[k];
    }
}

*output_len = j;
return 0;

}
4. 在 testsdf.c 中编写 main 函数测试四个转换功能
testsdf.c 文件

#include <stdio.h>
#include <stdlib.h>
#include “utils.h”

int main() {
// 测试字节数组到十六进制字符串的转换
uint8_t bytes1[] = {0x4a, 0x5b, 0x6c};
char hex[10];
bytes_to_hex(bytes1, 3, hex);
printf(“Bytes to Hex: %s\n”, hex);

// 测试十六进制字符串到字节数组的转换
const char *hex_str = "4a5b6c";
uint8_t bytes2[3];
size_t bytes2_len;
hex_to_bytes(hex_str, bytes2, &bytes2_len);
printf("Hex to Bytes: ");
for (size_t i = 0; i < bytes2_len; i++) {
    printf("%02x ", bytes2[i]);
}
printf("\n");

// 测试字节数组到 Base64 字符串的转换
char base64[10];
bytes_to_base64(bytes1, 3, base64);
printf("Bytes to Base64: %s\n", base64);

// 测试 Base64 字符串到字节数组的转换
const char *base64_str = "Smtj";
uint8_t bytes3[3];
size_t bytes3_len;
base64_to_bytes(base64_str, bytes3, &bytes3_len);
printf("Base64 to Bytes: ");
for (size_t i = 0; i < bytes3_len; i++) {
    printf("%02x ", bytes3[i]);
}
printf("\n");

return 0;

}
5. 编译和运行
编译代码
在终端中运行以下命令：

gcc -o testsdf testsdf.c utils.c
运行测试
在终端中运行以下命令：

./testsdf

Bytes to Hex: 4a5b6c
Hex to Bytes: 4a 5b 6c
Bytes to Base64: Smtj
Base64 to Bytes: 4a 5b 6c