Klasse für sehr große Zahlen

bool Int::compare_size(char *a, char*b, unsigned long long a_max, unsigned long long b_max)
{
    //Diese FUnktion liefert a >= b zurück
    //Nullen am Anfang von a und b entfernen
    check(a, a_max);
    check(b, b_max);
    //Überprüft ob a >= b gilt
    //Wenn a länger ist als b ist a > b
    if(a_max > b_max) return true;
    //Wenn b länger als ist als a ist b > a bzw. a < b
    else if(b_max > a_max) return false;
    /*Da a und b die gleiche Länge haben, werden jeweils zwei Zeichen a[i] und b[i] überprüft,
    ist a[i] > b[i] ist auch a größer b und es wird true zurückgegeben
    ist b[i] > a[i] ist b auch größer als a und es wird false zurückgegeben*/
    for(unsigned long long i = 0; i < a_max; i++)
        if(a[i] > b[i]) return true;
        else if(b[i] > a[i]) return false;
    //Es stimmen alle Zeichen überein, also ist a = b und somit a >= b
    return true;
}
bool Int::positiv_sub(char *a, char *b, unsigned long long& a_max, unsigned long long& b_max)
{
    //Die Funktion überprüft ob a >= b gilt, und rechnet wenn dies gilt a-= b aus. Es wird a >= b zurückgegeben, 
    //also ob die Subtraktion moeglich war
    //Wenn b größer ist, ist keine Subtraktion möglich
    if(!compare_size(a, b, a_max, b_max)) return false;
    //a_pos ist die aktuelle Position für die Subtraktion in a, b_pos die aktuelle Position in b
    //val ist die Ziffer die dann im Ergebnis an der Position j steht
    long long a_pos =  a_max - 1, b_pos = b_max - 1, val = 0, uebertrag = 0;
    for(int j = a_max - 1; j >= 0; j--) 
    { 
        val = -uebertrag; 
        uebertrag = 0;
 
        if(b_pos >= 0 && a_pos >= 0)   
        {             //Wenn die untere Ziffer kleiner als die obere Ziffer ist
            if(b[b_pos] <= a[a_pos])
            {
                val += (a[a_pos] - 48);
                val -= b[b_pos] - 48;
            }
            //Wenn die untere Ziffer größer als die obere Ziffer ist
            else if(b[b_pos] > a[a_pos])
            {
                val +=  10 + a[a_pos] - b[b_pos];                 uebertrag = 1;             }


        }


        if(b_pos >= 0 && a_pos < 0)
        {
            val +=  b[b_pos] - 48;             uebertrag = 1;


        }
        else if(a_pos >= 0 && b_pos < 0)
        {
            val += a[a_pos] - 48;
        }
        a[j] = val + 48;
        a_pos--;
        b_pos--;
    }
    //Überflüssige Nullen in a am Anfang entfernen
    check(a, a_max);
    return true;
}
Int Int::operator/=(const Int& a)
{
    //Wenn a falsch initialisiert wurde, oder a größer als this ist, oder a = 0, dann wird abgebrochen
    if(badformat || a.badformat || operator<(a) || a[0] == 0) return Int(0);
    unsigned long long divisor_max = 0;
    char *divisor;
    //Wenn das erste Zeichen von this größer ist, als das erste Zeichen von a
    if(operator[](0) < a[0])
    {
        divisor_max = max - 1;
        divisor = new char[divisor_max];
        //divisor übernimmt alle Zeichen von a
        for(long long m = 0; m < a.max; m++)
            divisor[m] = a[m]  + 48;
        //Es werden solange Nullen angefügt, wie divisor <= *this gilt
        for(long long m = a.max; m < divisor_max; m++)
            divisor[m] = 48;
    }
    else if(operator[](0 )>= a[0] )
    {
        divisor_max = max;
        divisor = new char[divisor_max];
        //divisor übernimmt alle Zeichen von a
        for(long long m = 0; m < a.max; m++)
            divisor[m] = a[m] +48;
        //Es werden solange Nullen angefügt, wie divisor <= *this gilt
        for(long long m = a.max; m < divisor_max; m++)
            divisor[m] = 48;
    }
    unsigned long long dividend_max = max;
    char * dividend = new char[dividend_max];
    //dividend übernimmt alle Ziffern von *this
    for(long long m = 0; m < dividend_max; m++) dividend[m] = operator[](m) + 48;
    //Das ergebnis kann maximal max + 1 - a.max Stellen haben
    char * ergebnis = new char[max - a.max + 1];
    long long temp = divisor_max;
    unsigned long long anzahl_ziffern = 0;
    //divisor_max - a.max ist die Anzahl der angefügten Nullen, solange die >= 0 ist wird die Schleife ausgeführt
    for(long long i = divisor_max - a.max; i >= 0; i--)
    {
        unsigned long long anzahl = 0;

        while(true)
        {
            //Die Schleife wird solange ausgefüht, wie dividend -= divisor >= 0 ist
            if(!positiv_sub(dividend, divisor, dividend_max, divisor_max)) break;
            anzahl++;
        }
        //Die letzte Null aus Divisor entfernen
        char *tmp = new char[--divisor_max];
        for(long long m = 0; m < divisor_max; m++)
            tmp[m] = divisor[m];
        delete divisor;
        divisor = new char[divisor_max];
        for(long long m = 0; m < divisor_max; m++) divisor[m] = tmp[m];
        //Das Ergebnis an der Stelle anzahl_ziffern ist die Anzahl, wie oft
        //die Subtraktion durchgeführt werden konnte
        ergebnis[anzahl_ziffern++] = anzahl + 48;
    }
    //das interne Array zum Speichern der Ziffern wird gelöscht, ihm wird ergebnis zugewiesen
    delete z;
    z = new char[anzahl_ziffern];
    for(unsigned long long i = 0; i < anzahl_ziffern; i++) 
        z[i] = ergebnis[i];
    if(vorzeichen != a.vorzeichen) vorzeichen = '-';
    else vorzeichen = '+';
    return *this;
}