Simpler Algorithmus zum Addieren beliebig großer Integer

Hallo,
ich wollte mir einen einfachen Algorithmus schreiben, der beliebig große unsigned integer addiert.
Die basis sieht so aus:

template<unsigned int N> class zahl
{
    unsigned int number["so viele unsigned ints wie man mindestens braucht, um N bits zu speichern"];
};

Gesetzt dem Fall, es liegt Little Endian vor und number[0] addressiert die niederwertigsten Bits und number[array_size-1] die höchstwertigsten, habe ich diesen Algorithmus geschrieben:

zahl& operator+=(const zahl& a)
{
    bool uebertrag = false;

    for(unsigned int i=0;i!=array_size;++i)
    {
        if(uebertrag)
        {
             for(unsigned int tmp=i; tmp!=array_size; ++tmp)
                 if(++number[tmp]) break; //übertrag auf die "zahl" anwenden
             uebertrag=false;
        }

        uebertrag = ( (uint_max-number[i]) < a.number[i] );
        number[i]+=a.number[i];
    }
    return *this;
}

Allerdings will der Algorithmus nicht so recht funktionieren, wenn das Ergebnis der Addition größer ist (also mehr bits hat), als in das Objekt passen. Sieht jemand spontan einen (Denk-)Fehler?

pumuckl

Na du hast es im grunde doch selber geschrieben. Du musst darauf vorbereitet sein, dass die Summe für die Darstellung ein Bit mehr braucht als jeder der beiden Summanden. Entsprechend muss die Arraygröße für das Ergebnis in dem Fall um eins erhöht werden, wenn dieses zusätzliche Bit nicht mehr in die alte Arraygröße passt.

Ich hatte einen kleinen Denkfehler in meinem Programm. Der Overflow soll so behandelt werden, wie es bei den POD's geschieht (d.h. die Anzahl der Bits bleibt stehts konstant). Allerdings hatte ich mit einer ungeraden Anzahl Bits getestet, sodass am ende kein übertrag mehr übrig blieb (der ist dann in den "padding bits" verschwunden).
Was haltet ihr von diesem Algorithmus? Gibt es bessere/schnellere Möglichkeiten, die addition zu realisieren?