wie addiert man denn am besten zwei 160-bit-Zahlen, die jeweils in einem 20-stelligen unsigned char* Puffer abgelegt sind? Die Puffer wurden irgendwann mal so definiert:

unsigned char* buff_a = new unsigned char[20];
unsigned char* buff_b = new unsigned char[20];

Mein Problem ist, dass die Wertebereiche ja viel zu groß sind, um das Ganze irgendwie in Integer oder Ähnliches umzuwandeln. Gibt es dazu vielleicht irgendwelche Funktionen, oder muss ich das char-Array Stelle für Stelle addieren und mich selbst um Bösheiten wie Übertrag und Überlauf kümmern?

Vielen Dank schon mal im Voraus

ich frag mich warum du unsigned char deklarierst

Die Dinger kommen aus einer Klasse, die für mich Strings hasht (SHA-1). Ich hab keinen Einfluss darauf, aber ich muss halt irgendwie mit den Hashwerten rechnen...

oder muss ich das char-Array Stelle für Stelle addieren und mich selbst um Bösheiten wie Übertrag und Überlauf kümmern?

Genauso schauts aus. Libs für grosse Zahlen machen das auch nichts anders. Und C++ hilft dir insofern, dass du diverse Bitoperatoren verwenden kannst, um dir das Leben etwas zu erleichtern.

LordSash schrieb:

ich frag mich warum du unsigned char deklarierst....das sagt dem kompiler doch nur ob die variablen nur positive vorzeichen haben

Und wo ist das Problem dabei?

#include <iostream>

int main() {
   char c = 1;
   unsigned char u = 1;
   c <<= 7;
   u <<= 7;
   std::cout << (int) c << '\n' << (int) u;
}

Hier erhält man als Ausgabe:
-128
128

D. h., verwendet man char als 8-bit-Zahl, so gibt es sehr wohl eine vorzeichenfreie und eine vorzeichenbehaftete Variante!

Dass char nur positiv ist, stimmt so nur bedingt.

Äh, die Bedingung im OP war dass man unsigned davor schreibt...

Und du hast noch einen weiteren Typ in deiner Aufzählung vergessen: signed char; die signedness von char ist implementation-defined.

die Bedingung im OP

Auch sehr schön...

unsingned char buff_c[20] = {0};
int übertrag = 0;
for( int j = 0 ; j < 20; ++j )
  for( int i = 0; i < 8; ++i )
  {
     int bita = buff_a[ j ] & 1 << i;
     int bitb = buff_b[ j ] & 1 << i;

     if( bita && bitb )
     {
         buff_c[ i ] = 1;
         if( !übertrag )
            übertrag = 1;            
     }
     elseif( bita || bitb )
     {
         buff_c[ i ] = bita ? bita : bitb;
     }
     else
     {
         if( übertrag )
         {
              buff_c[ i ] = 1;
              übertrag = 0;
         }
         //else buff_c[ i ] = 0; //nicht nötig, da buff_c eh mit nullen gefüllt ist
     }
  }

Jetzt nur so schnell hingeschrieben, müsst aber so gehen. Man sollte es allerdings etwas schöner machen