Umwandlung einer (binären) Ganzzahl in eine Zeichenfolge

[idontwantaname]

Hi!

Eines gleich vorab: Wie das ganze prinzipiell funktioniert weiß ich - also von Binär nach Dezimal, nur in dieser Größenordnung nicht

Ich möchte mir eine eigene Bibliothek schreiben, mit deren Hilfe man unendlich große Ganzzahlen und beliebig genaue (und endlos große) Dezimalzahlen darstellen und mit ihnen auch rechnen kann. Ich glaube, jemand anderer hier macht das selbe auch gerade, nur benötige ich es in C# und möchte es des Lernwertes wegen selbst machen!

Nun habe ich mir überlegt, die Daten intern in einem Byte-Array zu speichern und mit diesem dann die Rechenoperationen durchzuführen, was an sich kein allzu großes Problem sein sollte (zumindestens die vier Grundrechnungsarten). Jedenfalls habe ich keine Idee, wie ich dieses Byte-Array in eine Zeichenkette umwandeln kann! Solange das ganze den Integer bzw. Int64 Bereich nicht sprengt, ist das natürlich nicht sehr schwer, doch wenn die internen Datentypen nicht mehr ausreichen, dann weiß ich nicht mehr weiter.

Vom Prinzip her müsste ich ja lediglich den Zahlenwert mit 256 hoch dem Stellenwert multiplizieren und die Summe der Ergebnisse wäre die endgültige Zahl.

Code:

byte[] data = /* something */;

/* datatype */ number = 0;
for (int i = 0; i < data.Length; i++)
    number += data[i] * Math.Pow(256, i);

string num = Convert.ToString(number);

Die Umwandlung wäre auch nicht schwer, wenn die Basis des Dezimalsystems (also 10) ein Hochfaches (nicht Vielfaches ^^) von 2 wäre, so wie Octal (Basis 8, je 3 Bit pro Ziffer) oder Hexadezimal (Basis 16, je 4 Bit pro Ziffer/Zeichen).

Könnt ihr mit hilfreiche Tipps oder Links dazu geben bzw. habt ihr selbst Ideen, wie ich das am besten bewerkstellige?

Lg oli

[edit] Meine Frage richtet sich natürlich auch auf die Umwandlung von einer Zeichenkette zu einem Byte-Array

[himitsu]

wenn du es bei Integer hinbekommst, dann sollte es auch kein Problem dieses für deinen großen Typen zu schaffen ... du mußt dann nur dein Vogehen auf den "großen" Typen beziehen und mit desse Rechenoperatoren vorgehen.

hierfür wäre es aber optimaler, wenn du die 5. Grundrechenoperation auch noch einführst ... somit ersparrst du dir einige Rechenschritte.

(+) Addition
(-) Subtraktion
(*) Multiplikation
(div) Division
(mod) und Modulo
und am Besten vereinst du die Division und Modulo noch in einer DivMod
Function DivMod(X, Divisor: DeinIntTyp; Out Reminder: DeinIntTyp): DeinIntTyp; vom Prinzip her dividierst du deine Zahl durch Zehn, wandelst den Divionsrest in einen String und fügst ihn vorne in den Ergebnisstring ein:

Delphi-Quellcode:

X = deine Zahl (der große Integer)

S := ""
istNegativ := X < 0
schleife
  i := Modulo(X, 10)       // i := X mod 10;
  X := Division(X, 10)     // X := X div 10;
  S := IntToStr(i) + S
wiederhole wenn X > 0
wenn istNegativ dann S := "-" + S

oder

Delphi-Quellcode:

X = deine Zahl (der große Integer)

S := ""
istNegativ := X < 0
schleife
  Temp1 := X
  X := Division(X, 10)            // X := X div 10;
  Temp2 := Mutiplication(X)       // Temp2 := X * 10;
  i := Subtraktion(Temp1, Temp2)  // i := Temp1 - Temp2;
  S := IntToStr(i) + S
wiederhole wenn X > 0
wenn istNegativ dann S := "-" + S

mit DivMod

Delphi-Quellcode:

X = deine Zahl (der große Integer)

S := ""
istNegativ := X < 0
schleife
  X := DivMod(X, 10, i)
  S := IntToStr(i) + S
wiederhole wenn X > 0
wenn istNegativ dann S := "-" + S

und die Umkehrung:

Delphi-Quellcode:

S = dein String

X := 0;
schleife
  X := (X * 10) + StrToInt(S[1]);
  lösche erstes Zeichen aus S  // Delete(S,1,1); oder S:=Copy(S,2,Length(S));
wiederhole wenn S > ""

PS: wenn du nur die Werte von 0..99 pro Byte zuläßt und damit dann intern arbeitest, dann ginge es auch in etwa nach deiner Idee ... alo mit je 2 Stellen (bei einem Integer - 32 bit - wären je 9 Stellen möglich ... ich gleub beim VLI/VeryLargeInteger wurde es so gemacht)