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

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

#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;
}