Kalkulator dużych liczb całkowitych

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

int Dodawanie( char X[], char Y[], char Z[], int SIZE ) /*podprogram obslugujacy dodawanie liczb naturalnych o danej dlugosci nasladujacy dodawanie pisemne*/
{
    int i, suma;
    int p = 0; /*zmienna ktora wykorzystamy aby zwiekszac nastepny rzad, jesli suma w poprzednim bedzie wieksza niz 10, analogicznie jak w dodawaniu pisemnym*/
    Z[ SIZE + 1 ] = '\0'; /*rezerwujemy ostatnie miejsce w tablicy*/
    for( i = SIZE - 1; i >= 0; i-- )
    {
        suma = X[ i ] - '0' + Y[ i ] - '0' + p; /* '0' jest odpowiednikiem 48, nale¿y to odejmowac od char aby otrzymac szukany int. Przy pierwszym obrocie dodajemy po prostu cyfry jednosci, potem cyfry dziesiatek powiekszone o "nadwyzke z jednosci", czyli p, itd. */
        Z[ i + 1 ] = suma % 10 + '0'; /*poniewaz moze sie zdarzyc tak, ze wynik bedzie mial nie 32, a 33 cyfry, komorka "i+1" wyniku odpowiada komorkom "i" tablic sumowanych. Jesli wynik wyjdzie 32 cyfrowych to nie szkodzi, jako cyfra najwyzszego rzedu wpisane zostanie 0*/
        p = suma / 10; /*p, czyli "nadwyzka", jest liczba calkowita. Zauwazmy, ze jesli przyjmiemy, ze suma jest int, to suma%10+suma/10=suma*/
    }
    Z[ 0 ] = p + '0'; /*tutaj wlasnie miejsce najwyzszego rzedu w wyniku okazuje sie albo zerem, albo nadwyzka z dodawania najwyzszych rzedow tablic sumowanych*/
    return p;
}
int Odejmowanie( char X[], char Y[], char Z[], int SIZE ) /*podprogram obslugujacy odejmowanie liczb naturalnych o danej dlugosci nasladujacy odejmowanie pisemne*/
{
    int i, roznica;
    int p = 0;
    Z[ SIZE + 1 ] = '\0';
    for( i = SIZE - 1; i >= 0; i-- )
    {
        roznica = X[ i ] - '0' - Y[ i ] + '0' + p; /*tak jak w Dodawaniu dodawalismy komorki, tak tu je odejmujemy w analogicznej petli*/
        if( roznica >= 0 ) /*jesli roznica w danym rzedzie jest nieujemna nic specjalnego nie musimy robic: p=0, a w tablicy wyniku zapisujemy po prostu roznice dwoch cyfr*/
        {
            Z[ i + 1 ] = roznica % 10 + '0';
            p = roznica / 10;
        }
        else /*jesli roznica jest ujemna to "pozyczamy" od wyrazu wyzszego rzedu, zmniejszajac go o 1 i dodajac jednoczesnie 10 do wyrazu nizszego rzedu - tak samo jak w odejmowaniu pisemnym*/
        {
            Z[ i + 1 ] = roznica % 10 + 10 + '0';
            p = roznica / 10 - 1;
        } /*problem pojawia sie gdy od mniejszej liczby odejmujemy wieksza, ale rozwiazujemy go dalej, juz w menu kalkulatora*/
    }
    Z[ 0 ] = p + '0'; /*w odejmowaniu nie ma to juz takiego znaczenia jak w dodawniu, ale zostawmy by sposob wyswietlania wyniku byl taki sam jak w podprogramie Dodawanie, z zerem na poczatku*/
    return p;
}

int main()
{
    int symbol, symbol2; /* do przechowania symboli liczb, dzieki temu obslugujemy nie tylko liczby naturalne, ale i calkowite */
    int operacja; /* do switch, wybiera dodawanie lub odejmowanie */
    const int SIZE = 32; /*dzieki const mozemy w razie potrzeby zmienic program by dzialal nie tylko dla liczb 32-cyfrowych, ale i dla wiekszych lub mniejszych. Przydatne rowniez gdy chcemy przetestowac jego dzialanie - zmieniamy po prostu SIZE na mniejsza liczbe i jest wygodniej sledzic poprawnosc wyniku */
   
    printf( "KALKULATOR DODAWANIA I ODEJMOWANIA\n"
    "----------------------------------------------------------------------------\n"
    "Podaj symbol przed liczba, ktorej modul jest wiekszy (wybierz 1 jesli + lub 2 jesli -): \n" );
    scanf( "%d", & symbol );
    printf( "Podaj modul tej liczby: \n" );
    char A[ SIZE ]; /* liczby sa na tyle duze, ze musimy je przechowywac w tablicach. Miejsca od 0 do SIZE-1 sa przeznaczone na cyfry, miejsce SIZE jest zarezerwowane jako ostatnia komorka tablicy */
    scanf( "%s", A );
   
    printf( "Podaj symbol przed druga liczba (wybierz 1 jesli + lub 2 jesli -): \n" );
    scanf( "%d", & symbol2 );
    printf( "Podaj modul drugiej liczby: \n" );
    char B[ SIZE ];
    scanf( "%s", B );
   
    char C[ SIZE + 1 ]; /* tablica C przechowuje wynik, dlatego musi byc wieksza od pozostalych tablic - suma dwoch liczb dodatnich 32-cyfrowych moze miec 33 cyfry, podobnie jak roznica dwoch liczb ujemnych*/
    printf( "Wybierz operacje: \n1. Dodawanie. \n2. Odejmowanie. \nInny: Opusc program\n" );
    scanf( "%d", & operacja );
   
    switch( operacja ) /*warunek wielokrotnego wyboru switch pozwala nam wykorzystac funkcje napisana dla liczb naturalnych w ten sposob, by dzialala takze dla liczb calkowitych */
    {
    case 1:
        {
            if( symbol == 1 && symbol2 == 1 ) /*zwyczajna suma liczb naturalnych ktorej dzialanie wynika wprost z podprogramu Dodawanie*/
            {
                Dodawanie( A, B, C, SIZE );
                printf( "Dodawanie: %s \n", C );
            }
            else if( symbol == 1 && symbol2 == 2 ) /*sume liczby dodatniej i ujemnej odczytujemy jako roznice modulow tych dwoch liczb*/
            {
                Odejmowanie( A, B, C, SIZE );
                printf( "Dodawanie: %s \n", C );
            }
            else if( symbol == 2 && symbol2 == 1 ) /*analogicznie jak powyzej, dopisujemy jednak minus, bo liczba ujemna ma wiekszy modul*/
            {
                Odejmowanie( A, B, C, SIZE );
                printf( "Dodawanie: -%s \n", C );
            }
            else /*suma 2 liczb ujemnych odczytywana jest jako suma ich modulow z dopisanym minusem*/
            {
                Dodawanie( A, B, C, SIZE );
                printf( "Dodawanie: -%s \n", C );
            }
            break;
        }
    case 2:
        {
            if( symbol == 1 && symbol2 == 1 ) /*zwyczajna roznica liczb naturalnych ktorej dzialanie wynika wprost z podprogramu Odejmowanie. Pamietamy, ze pierwsza z wpisanych liczb jest wieksza, o co wczesniej prosilismy wpisujacego i mialo to zastosowanie takze przy dodawaniu*/
            {
                Odejmowanie( A, B, C, SIZE );
                printf( "Odejmowanie: %s \n", C );
            }
            else if( symbol == 1 && symbol2 == 2 ) /*jesli odejmiemy od liczby dodatnia liczbe ujemna to tak naprawde dodajemy ich moduly, wiec wykorzystujemy po prostu podprogram Dodawanie*/
            {
                Dodawanie( A, B, C, SIZE );
                printf( "Odejmowanie: %s \n", C );
            }
            else if( symbol == 2 && symbol2 == 1 ) /*jesli odejmiemy od liczby ujemnej liczbe dodatnia to otrzymamy sume ich modulow zapisana z minusem*/
            {
                Dodawanie( A, B, C, SIZE );
                printf( "Odejmowanie: -%s \n", C );
            }
            else /*roznica 2 liczb ujemnych odczytywana jest jako roznica ich modulow z dolaczonym minusem w wyniku*/
            {
                Odejmowanie( A, B, C, SIZE );
                printf( "Odejmowanie: -%s \n", C );
            }
            break;
        }
        default: /*wyjscie z programu na wypadek gdybysmy pomylili sie przy wpisywaniu liczb, sa raczej dlugie*/
        exit( 0 );
    }
    return 0;
}