Calculadora Infinita

ATUALIZADO!!!
Obs.:Fiz até aqui,mas não consigo mostrar minha lista de números,é só tirar os “bla.digito[i]=conversor(ch);” e o “ble.digito[j]=conversor(ch);” que eles aparecem,e não sei pq eles poderiam estar dando problema.Alguma luz?(Na soma ainda…)Não formatei direito,faço no codeblocks por causa da facul,e o txt ta mesma pasta e talz…

Meu trabalho de faculdade é fazer uma calculadora de 4 operações infinita no qual qualquer número de qualquer tamanho pode ser calculado (com isso estipula-se qualquer número que possa talvez até estourar a capacidade da variável),alocar esse número até que sei como usando arrays e tal,mas depois fazer operações com eles é o complicado,alguma dica ou modo que eu possa começar a fazer isso?

#include <stdio.h>
typedef struct {
double *digito;
}numero;

double soma(numero bla,numero ble,int i,int j){
numero blu;
int g=0,c=1,t,z;
t=i;z=j;
blu.digito=calloc(1,sizeof(double));
if(i<j){
while(i>=0){
blu.digito = realloc(blu.digito,(++c)*sizeof(double));
//blu.digito[g]=NULL;
blu.digito[g]=bla.digito[i]+ble.digito[j];
if(blu.digito[g]>9){
blu.digito[g]=blu.digito[g]-10;
ble.digito[j–]=1+ble.digito[j–];
j++;
}
g++;
i–;j–;
}
while(j>=0){
blu.digito = realloc(blu.digito,(++c)*sizeof(double));
//blu.digito[g]=NULL;
blu.digito[g]=0+ble.digito[j];
if(blu.digito[g]>9){
blu.digito[g]=blu.digito[g]-10;
ble.digito[j–]=1+ble.digito[j–];
j++;
}
g++;
j–;
}
printf(“RESULTADO: \n”);
while(g>=0){
printf("%dXXX",blu.digito[g]);
g–;
}
}else{
while(j>=0){
blu.digito = realloc(blu.digito,(++c)*sizeof(double));
//blu.digito[g]=NULL;
blu.digito[g]=bla.digito[i]+ble.digito[j];
if(blu.digito[g]>9){
blu.digito[g]=blu.digito[g]-10;
bla.digito[i–]=1+bla.digito[i–];
i++;
}
g++;
i–;j–;
}
while(i>=0){
blu.digito = realloc(blu.digito,(++c)*sizeof(double));
//blu.digito[g]=NULL;
blu.digito[g]=0+bla.digito[i];
if(blu.digito[g]>9){
blu.digito[g]=blu.digito[g]-10;
bla.digito[i–]=1+bla.digito[i–];
i++;
}
g++;
i–;
}
printf(“RESULTADO: \n”);
while(g>=0){
printf("%dxxx",blu.digito[g]);
g–;
}
}
}

int menu(numero bla,numero ble,int i,int j){
int opcao;
printf("\n\nCALCULADORA ‘INFINITA’\n");
printf(“OPCOES:(digite numero correspondente)\n”);
printf(“1-SOMA\n”);
printf(“2-SUBTRAÇÃO\n”);
printf(“3-MULTIPLICAÇÃO\n”);
printf(“4-DIVISÃO\n”);
printf(“5-RESTO\n”);
printf(“6-SAIR\n”);
scanf("%d",&opcao);
if((opcao<0)||(opcao>6)){
printf(“Opção inválida”);
//menu();
}
switch(opcao){
case 1:
soma(bla,ble,i,j);
break;
case 2:
//subtracao();
break;
case 3:
//multiplicacao();
break;
case 4:
//divisao();
break;
case 5:
//resto();
break;
}
}

double conversor(char cho){
numero blas;int ii=0;
if(cho==‘0’){
blas.digito[ii]=0;
}else if(cho==‘1’){
blas.digito[ii]=1;
}else if(cho==‘2’){
blas.digito[ii]=2;
}else if(cho==‘3’){
blas.digito[ii]=3;
}else if(cho==‘4’){
blas.digito[ii]=4;
}else if(cho==‘5’){
blas.digito[ii]=5;
}else if(cho==‘6’){
blas.digito[ii]=6;
}else if(cho==‘7’){
blas.digito[ii]=7;
}else if(cho==‘8’){
blas.digito[ii]=8;
}else if(cho==‘9’){
blas.digito[ii]=9;
}
return blas.digito[ii];
}

int main(void)
{
char url[]=“teste.txt”;
char ch;
FILE *arq;
numero bla,ble;
int i=0,j=0,cont=0,contt=1,aux;
bla.digito=calloc(1,sizeof(double));
ble.digito=calloc(1,sizeof(double));

arq = fopen(url, "r");
if(arq == NULL){
    printf("Erro, nao foi possivel abrir o arquivo\n");
}else{
    while( (ch=fgetc(arq))!= EOF ){
        if((ch=='\n')||(ch=='\r')){
            break;
        }
    putchar(ch);
    bla.digito = realloc(bla.digito,(++cont)*sizeof(double));
    bla.digito[i]=conversor(ch);
    }
printf("\n\n");
    while( (ch=fgetc(arq))!= EOF ){
        putchar(ch);
        ble.digito = realloc(ble.digito,(++contt)*sizeof(double));
        ble.digito[j]=conversor(ch);
    }
}
fclose(arq);
menu(bla,ble,cont,contt);
return 0;

}

Tudo bem?

Não sei se isso é válido para o seu trabalho mas pense em um número tipo esse:

9000.000.000.000.000.000.000.000.000.000, ele pode ser representado assim 9*10^30 é uma maneira de armazenar números muito grandes.

Para realizar as operações você vai ter que trabalhar com esse formato, e pense que esse formato será exibido na tela em forma de string, ou seja ele será armazenado em uma string.

Para que este valor continue crescendo pense em alocar memória para sua string. Se você for trabalhar com C pense em alocação dinâmica malloc é realloc são o caminho, se for em C++11 use o header <list>

Se quiser exibir este número gigantesco na sua forma real, você terá que implementar outro algoritmo que armazenará pedaços deste número na memória que serão concatenados posteriormente para formar sua string final.

Vai dar um trabalho fazer isso mas é um algoritmo interessante.

Qualquer dúvida posta ae que tentaremos ajudar. Boa sorte.