将十六进制数字字符串转换成十进制数字字符串

将十六进制数字字符串转换成十进制数字字符串

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

char * hex2dec(const char * source);

int main(int argc, char *argv[])
{
    char * hex = "fffffffffffffff";
    char * dec = hex2dec(hex);
    printf("%s", dec);
    printf("/n");

    return 0;
}

char * hex2dec(const char * source)
{
    int last_non_zero_pos, i, hex_index;
    char * dec_string;

    /* log(16) = 1.204 */
    const double length_rate = 1.3;

    int hex_length = strlen(source);
    int dec_length = hex_length * length_rate + 1;

    /* Result goes here. */
    int * dec = (int *)malloc(dec_length * sizeof(int));

    /* Value of 0x1, 0x10, 0x100, 0x1000, ... */
    int * curr = (int *)malloc(dec_length * sizeof(int));

    for (i = 0; i < dec_length; i++)
    {
        dec[i] = curr[i] = 0;
    }

    /* 0x1 = 0000000000001(10) */
    curr[0] = 1;

    for (hex_index = 0; hex_index < hex_length; hex_index++)
    {
        /* Convert from right to left. */
        int hex_pos = hex_length - 1 - hex_index;
        char hex_curr_value = source[hex_pos];
        int dec_curr_value, dec_index, curr_index;

        /* Convert a single hex to dec. */
        if (hex_curr_value <= '9' && hex_curr_value >= '0')
        {
            dec_curr_value = hex_curr_value - '0';
        }
        else if (hex_curr_value <= 'f' && hex_curr_value >= 'a')
        {
            dec_curr_value = hex_curr_value - 'a' + 10;
        }
        else if (hex_curr_value <= 'F' && hex_curr_value >= 'A')
        {
            dec_curr_value = hex_curr_value - 'A' + 10;
        }

        /* Add this hex to dec result. */
        for (dec_index = 0; dec_index < dec_length; dec_index++)
        {
            dec[dec_index] += dec_curr_value * curr[dec_index];
        }
        for (dec_index = 0; dec_index < dec_length; dec_index++)
        {
            dec[dec_index + 1] += dec[dec_index] / 10;
            dec[dec_index] = dec[dec_index] % 10;
        }

        /* 0x1->0x10, 0x10->0x100, 0x100->0x1000, ... */
        for (curr_index = 0; curr_index < dec_length; curr_index++)
        {
            curr[curr_index] *= 16;
        }
        for (curr_index = 0; curr_index < dec_length; curr_index++)
        {
            curr[curr_index + 1] += curr[curr_index] / 10;
            curr[curr_index] = curr[curr_index] % 10;
        }
    }

    /* The output is reversed, so we should reverse it. */
    last_non_zero_pos = dec_length - 1;
    while (0 == dec[last_non_zero_pos])
    {
        last_non_zero_pos--;
    }
    dec_string = (char *)malloc((last_non_zero_pos + 2) * sizeof(char));
    for (i = 0; i < last_non_zero_pos + 1; i++)
    {
        dec_string[i] = dec[last_non_zero_pos - i] + '0';
    }

    free(dec);
    free(curr);

    return dec_string;
}