Разработать структуру “bigint” для выполнения операций с целыми числами содержащими произвольное количество знаков

structure bigint {
char *data;
size_t size;
int neg;
}

bigint createBigintFromUnsInt(unsigned long int*);
bigint createBigintFromInt(long int*);
bigint createBigintFromBI(bigint*);
bigint createBigintFromChar(char*);
bigint createBigint();

bigint add(const bigint* left, const bigint* right); // сложение
bigint sub(const bigint* left, const bigint* right); // вычитание
bigint mul(const bigint* left, const bigint* right); // умножение
bigint div(const bigint* left, const bigint* right);  // целочисленное деление
bigint div(const bigint* left, const bigint* right, bigint* res); // деление с остатком

void printBigint(const bigint*);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
structure bigint 
{
char *data;
size_t size;
int neg;
} bigint;
 
bigint createBigintFromUnsInt(unsigned long int *n)
{
    bigint b = {0};
    b.neg = 0;
    b.size = 0;
    b.data = malloc(sizeof(char));
    if (*n == 0)
    {
        b.size = 1;
        b.data[0] = 0;
        return b;
    }
    while (*n > 0)
    {
        b.data = realloc(b.data, ++b.size*sizeof(char));
        b.data[b.size - 1] = *n%10;
        *n / =10;  
    }
    return b;
}
 
bigint createBigintFromInt(long int *n)
{
    bigint b = {0};
    if (*n < 0)
    {
        b = createBigintFromUnsInt((unsigned long int*)n);
        b.neg = 1;
    }
    else
    {
        b = createBigintFromUnsInt((unsigned long int*)n);
    }
    return b;
}
 
bigint createBigintFromBI(bigint *bi)
{
    bigint b = {0};
    b.neg = bi->neg;
    b.size = bi->size;
    b.data = malloc(b.size * sizeof(char));
    memcpy(b.data, bi->data, b.size * sizeof(char))
    return b;
}
 
bigint createBigintFromChar(char *str)
{
    bigint b = {0};
    if (str[0]=='-')
    {
        b.neg = 1;
        str++;
    }
    else
    {
        b.neg = 0
    }
    b.size = strlen(str);
    b.data = malloc(b.size * sizeof(char));
    for (size_t i =0; i < b.size; i++)
    {
        b.data[i] = str[b.size - 1 - i] - '0';
    }
    return b;
}
 
bigint createBigint()
{
    bigint b = {0};
    b.neg = 0;
    b.size = 1;
    b.data = malloc(sizeof(char));
    b.data[0] = 0;
    return b;
}

bigint add(const bigint* left, const bigint* right){
    // Определяем где большее число.
    const bigint* bigger = left->size > right->size ? left : right;
    const bigint* less = bigger == left ? right : left;
 
    int ovf = 0;
    bigint result = createBigintFromBI(bigger);
    
    size_t i = 0;
    if(left->neg == right->neg){ // Проверяем на разность знаков
        while(i < less->size){
            result->data[i] = bigger->data[i] + bigger->data[i] + ovf;
            ovf = (256 - bigger->data[i] - ovf < less->data[i]) ? 1 : 0; // Проверяем на переполнение
        }
        if(req){ // Если младшие разряды сложили, но остался перенос с прошлой операции.
            while(!++(result->data[i]) && i != bigger->size) i++;
            if(i == bigger->size && result->data == 0){ 
                realloc(result->data, ++(result->size)*sizeof(char);
                result->data[result->size] = 1;
            }
        }
    }
    else{ // Этот блок должен обрабатывать числа с разными знаками.
        
    }
    
    return result;
}

void destroi_bigint(bigint val){
    free(val->data);
}