用c语言编写一个可以加减乘除的16进制计算器，并给代码写上注释

好的，这是一个使用C语言编写的16进制计算器，可以进行加减乘除四则运算。以下是代码以及注释：

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

// 定义一个结构体用于存储16进制数
typedef struct
{
    int len;  // 数字长度
    char *num;  // 数字每一位的字符数组
} Hex;

// 将10进制数字转换为16进制字符
char dec2hex(int num)
{
    if (num >= 0 && num <= 9)
    {
        return num + '0';
    }
    else if (num >= 10 && num <= 15)
    {
        return num - 10 + 'A';
    }
    else
    {
        printf("Error: Invalid decimal number %d\n", num);
        exit(1);
    }
}

// 将16进制字符转换为10进制数字
int hex2dec(char c)
{
    if (c >= '0' && c <= '9')
    {
        return c - '0';
    }
    else if (c >= 'A' && c <= 'F')
    {
        return c - 'A' + 10;
    }
    else if (c >= 'a' && c <= 'f')
    {
        return c - 'a' + 10;
    }
    else
    {
        printf("Error: Invalid hex character %c\n", c);
        exit(1);
    }
}

// 初始化一个16进制数
Hex *init_hex(int len)
{
    Hex *h = (Hex *)malloc(sizeof(Hex));
    h->len = len;
    h->num = (char *)malloc(sizeof(char) * (len + 1));
    memset(h->num, '0', len);  // 初始化每一位为0
    h->num[len] = '\0';
    return h;
}

// 释放16进制数所占用的内存
void free_hex(Hex *h)
{
    free(h->num);
    free(h);
}

// 将16进制数转换为字符串
char *hex2str(Hex *h)
{
    char *str = (char *)malloc(sizeof(char) * (h->len + 1));
    memcpy(str, h->num, h->len + 1);
    return str;
}

// 将字符串转换为16进制数
Hex *str2hex(char *str)
{
    int len = strlen(str);
    Hex *h = init_hex(len);
    memcpy(h->num, str, len);
    return h;
}

// 删除16进制数前面的0
void trim_zero(Hex *h)
{
    int i;
    for (i = 0; i < h->len - 1; i++)
    {
        if (h->num[i] != '0')
        {
            break;
        }
    }
    if (i > 0)
    {
        h->len -= i;
        memcpy(h->num, h->num + i, h->len + 1);
    }
}

// 比较两个16进制数的大小，相等返回0，h1较大返回1，h2较大返回-1
int cmp_hex(Hex *h1, Hex *h2)
{
    int i;
    if (h1->len > h2->len)
    {
        return 1;
    }
    else if (h1->len < h2->len)
    {
        return -1;
    }
    else
    {
        for (i = 0; i < h1->len; i++)
        {
            if (h1->num[i] > h2->num[i])
            {
                return 1;
            }
            else if (h1->num[i] < h2->num[i])
            {
                return -1;
            }
        }
        return 0;
    }
}

// 计算两个16进制数的和
Hex *add_hex(Hex *h1, Hex *h2)
{
    int i, j, k;
    int carry = 0;  // 进位
    Hex *h = init_hex(h1->len > h2->len ? h1->len : h2->len);  // 结果最多有max(h1.len, h2.len)+1位
    for (i = h1->len - 1, j = h2->len - 1, k = h->len - 1; k >= 0; i--, j--, k--)
    {
        int a = i >= 0 ? hex2dec(h1->num[i]) : 0;
        int b = j >= 0 ? hex2dec(h2->num[j]) : 0;
        int sum = a + b + carry;
        h->num[k] = dec2hex(sum % 16);
        carry = sum / 16;
    }
    trim_zero(h);
    return h;
}

// 计算两个16进制数的差
Hex *sub_hex(Hex *h1, Hex *h2)
{
    int i, j, k;
    int borrow = 0;  // 借位
    Hex *h = init_hex(h1->len);  // 结果最多有h1.len位
    for (i = h1->len - 1, j = h2->len - 1, k = h->len - 1; k >= 0; i--, j--, k--)
    {
        int a = i >= 0 ? hex2dec(h1->num[i]) : 0;
        int b = j >= 0 ? hex2dec(h2->num[j]) : 0;
        int diff = a - b - borrow;
        if (diff < 0)
        {
            diff += 16;
            borrow = 1;
        }
        else
        {
            borrow = 0;
        }
        h->num[k] = dec2hex(diff);
    }
    trim_zero(h);
    return h;
}

// 计算两个16进制数的积
Hex *mul_hex(Hex *h1, Hex *h2)
{
    int i, j, k;
    Hex *h = init_hex(h1->len + h2->len);  // 结果最多有h1.len+h2.len位
    for (i = h1->len - 1; i >= 0; i--)
    {
        int carry = 0;
        for (j = h2->len - 1, k = i + h2->len; j >= 0; j--, k--)
        {
            int a = hex2dec(h1->num[i]);
            int b = hex2dec(h2->num[j]);
            int prod = a * b + carry + hex2dec(h->num[k]);
            h->num[k] = dec2hex(prod % 16);
            carry = prod / 16;
        }
        h->num[i] = dec2hex(carry);
    }
    trim_zero(h);
    return h;
}

// 计算两个16进制数的商和余数
void divmod_hex(Hex *h1, Hex *h2, Hex **q, Hex **r)
{
    int i, j, k;
    Hex *q1 = init_hex(h1->len);  // 商
    Hex *r1 = init_hex(h1->len);  // 余数
    Hex *h2_copy = init_hex(h2->len);
    memcpy(h2_copy->num, h2->num, h2->len);
    trim_zero(h2_copy);
    for (i = 0; i < h1->len; i++)
    {
        r1->num[i] = h1->num[i];
        while (cmp_hex(r1, h2_copy) >= 0)
        {
            for (j = 1; j <= h2_copy->len; j++)
            {
                if (r1->num[i + h2_copy->len - j] < h2_copy->num[h2_copy->len - j])
                {
                    r1->num[i + h2_copy->len - j] += 16 - h2_copy->num[h2_copy->len - j];
                    k = i + h2_copy->len - j - 1;
                    while (k >= i && r1->num[k] == '0')
                    {
                        r1->num[k] = 'F';
                        k--;
                    }
                    r1->num[k]--;
                }
                else
                {
                    r1->num[i + h2_copy->len - j] -= h2_copy->num[h2_copy->len - j];
                }
            }
            q1->num[i]++;
            trim_zero(r1);
        }
    }
    trim_zero(q1);
    trim_zero(r1);
    free_hex(h2_copy);
    *q = q1;
    *r = r1;
}

int main()
{
    char op;
    char *str1, *str2;
    Hex *h1, *h2, *h;
    Hex *q, *r;

    // 输入两个16进制数和运算符
    printf("Please enter two hexadecimal numbers and an operator (+, -, *, /):\n");
    str1 = (char *)malloc(sizeof(char) * 100);
    str2 = (char *)malloc(sizeof(char) * 100);
    scanf("%s %s %c", str1, str2, &op);

    // 将字符串转换为16进制数
    h1 = str2hex(str1);
    h2 = str2hex(str2);

    // 根据运算符进行计算
    if (op == '+')
    {
        h = add_hex(h1, h2);
    }
    else if (op == '-')
    {
        h = sub_hex(h1, h2);
    }
    else if (op == '*')
    {
        h = mul_hex(h1, h2);
    }
    else if (op == '/')
    {
        divmod_hex(h1, h2, &q, &r);
        printf("%s / %s = %s, %s %% %s = %s\n", hex2str(h1), hex2str(h2), hex2str(q), hex2str(h1), hex2str(h2), hex2str(r));
        free_hex(q);
        free_hex(r);
        free_hex(h1);
        free_hex(h2);
        free(str1);
        free(str2);
        return 0;
    }
    else
    {
        printf("Error: Invalid operator %c\n", op);
        free_hex(h1);
        free_hex(h2);
        free(str1);
        free(str2);
        return 1;
    }

    // 输出结果
    printf("%s %c %s = %s\n", str1, op, str2, hex2str(h));

    // 释放内存
    free_hex(h);
    free_hex(h1);
    free_hex(h2);
    free(str1);
    free(str2);

    return 0;
}

希望能对您有所帮助！