Преобразовать массив чисел char в hex

#include <stdio.h>
#include <memory.h>

void add_chr(char *big, char n /* 0..15 */, size_t len) {
        for (*big += n; *big > 15 && --len; *big &= 15, ++*++big);
        *big &= 15;
}

void add_big(char *a, const char *b, size_t len) {
        while (len)
                add_chr(a++, *b++, len--);
}

void shl_big(char *big, char n /* 0..3 */, size_t len) {
        big += --len;
        *big = (*big << n) & 15;
        for (--big; len--; --big)
                *big = ((*big << n) & 15) | (big[-1] >> (4 - n));
}

int main() {
        char a[64], b[64];
        const char *num = "3224833640520308023", *p;

        memset(a, 0, sizeof a);

        for (p = num; *p; ++p) {
                shl_big(a, 1, sizeof a);
                memcpy (b, a, sizeof a);
                shl_big(b, 2, sizeof b);
                add_big(a, b, sizeof a);
                add_chr(a, *p - '0', sizeof a);
        }
        p = a + sizeof a;
        while (--p > a && !*p);
        while (p >= a)
                putchar("0123456789ABCDEF"[(int) *p--]);
        putchar('\n');

        return 0;
}

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

struct node {
    struct node* next;
    uint32_t data;
};

typedef struct node* nodep;

nodep add_node(nodep n,int reverse) {
    nodep buf = malloc(sizeof(struct node));
    if(buf == NULL) {
        printf("malloc problem\n");
        return NULL;
    }
    if(reverse == 0) {
        n->next = buf;
        buf->next = NULL;
    } else {
        buf->next = n;
    }
    buf->data = 0;
    return buf;
};

nodep create_num(char *s) {
    nodep head = malloc(sizeof(struct node));
    if (head == NULL) {
        return NULL;
    }
    head->next = NULL;
#define MAX_NUM 9
#define NUM_POWER 1000000000
    uint32_t len = strlen(s);
    uint32_t i = 0;
    int needed_pos = len % MAX_NUM;
    if(needed_pos == 0) {
        needed_pos = MAX_NUM;
    }
    uint32_t power = pow(10, needed_pos); /*max 9 numbers*/
    uint32_t data = 0;
    nodep tail = head;
    for(; i < len; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            power /= 10;
            data += (s[i] - '0')*power;
            if (power == 1) {
                tail->data = data;            
                power = NUM_POWER;
                data = 0;
                if(len-i != 1) {
                    tail = add_node(tail, 0);
                }
            }
        } else {
            printf("not a num\n");
            return NULL;
        }
    }
    return head;
}

void print_long_num(nodep head, int hex) {
    nodep buf = head;
    while(buf != NULL) {
        if (hex == 0) {
            if(buf == head) {
                printf("%d", buf->data);
            } else {
                printf("%09d", buf->data);
            }
        } else {
            if(buf == head) {
                printf("%x", buf->data);
            } else {
                printf("%08x", buf->data);
            }
        }
        buf = buf->next;
    }
}

nodep del_node(nodep n) {
    nodep buf = n->next;
    free(n);
    return buf;
}

int div2_and_mod(nodep *head) {
    uint32_t modulo = 0;
    nodep iter = *head;
    while(iter != NULL) {
        uint32_t buf = NUM_POWER*modulo + iter->data;
        modulo = buf % 2;
        iter->data = buf / 2;
        if ((iter == *head) && (iter->data == 0)) {
            iter = del_node(iter);
            *head = iter;
        } else {
            iter = iter->next;
        }
    }
    return modulo;
}

nodep collect_data(nodep head, uint32_t data) {
    nodep buf = add_node(head,1);
    buf->data = data;
    return buf;
}

int main(int argc, char **argv)
{
    if (argc < 2) {
        printf("no number\n");
        return 1;
    }

    printf("start\n");

    nodep head = NULL;
    nodep hexhead = NULL;
    head = create_num(argv[1]);
    print_long_num(head, 0);
    printf("\n");

    uint8_t modulo;
    uint8_t buf_byte = 0;
    uint32_t buf_word = 0;
    uint8_t *pbyte = (uint8_t *)&buf_word;
    int bitcounter = 0;
    int bytecounter = 0;
    while (head != NULL) {
        modulo = div2_and_mod(&head);

        /*x86 specific*/
        buf_byte += (modulo << bitcounter); 
        bitcounter++;
        if (bitcounter == 8 || head == NULL) {
            pbyte[bytecounter] = buf_byte;
            bytecounter += 1;
            bitcounter = 0;
            buf_byte = 0;
        }

        if (bytecounter == 4 || head == NULL) {
            hexhead = collect_data(hexhead, buf_word); 
            bytecounter = 0;
            buf_word = 0;
        }
    }
    print_long_num(hexhead, 1);
    printf("\n");
    printf("end\n");

    /*FIXME release hexhead*/
    return 0;
}

$ gcc numbers.c -lm
$ ./a.out 3224833640520308023
start
3224833640520308023
2cc0e91c32f15537
end

#include <gmpxx.h>
#include <iostream>

int main( int argc, char **argv )
{
	if( argc > 1 )
		std::cout << mpz_class( argv[ 1 ] ).get_str( 16 ) << std::endl;
}