String -> Zahl in einzelne Bits < übersteigend double
-
Hallo,
ich schreibe ja wie gesagt gerade an einem eigenen Typ DQL (Double Quadruple Long).
Nun will ich strings einlesen und diese binär verwenden.
Man übergibt also: "1234567890123456789012345678901234567890"
und ich möchte das jetzt irgendwie vorliegen haben oder irgendwie in meine Bits bekommen.
Da ich mit der gesamten 256 Bitkette keine Probleme habe, darf man folgendes annehmen:bit b[256];Also, falls mir jemand helfen kann, kann er im Pseudocode einfach sowas angeben, ich wäre euch tief verbunden, ich habe echt keinen Plan.
MfG MAV
-
warum willst du in die Bit darstellung-
Schau mal in den Source der C Runtimelibrary wie die 64 Bit Integer versarbeiten und erweitere das Verfahren auf 256 Bit.
LARGE_INTEGER
The LARGE_INTEGER structure is used to represent a 64-bit signed integer value.Note Your C compiler may support 64-bit integers natively. For example, Microsoft
Visual C++ supports the __int64 sized integer type. For more information, see the documentation included with your C compiler.typedef union _LARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
};
LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
Members
LowPart
Specifies the low-order 32 bits.
HighPart
Specifies the high-order 32 bits.
QuadPart
Specifies a 64-bit signed integer.
Remarks
The LARGE_INTEGER structure is actually a union. If your compiler has built-in support for 64-bit integers, use the QuadPart member to store the 64-bit integer. Otherwise, use the LowPart and HighPart members to store the 64-bit integer.Um die einzelnen 32 Bit Wörter zu füllen kannst du den Sting von rechts nach links auflösen
-
Um die einzelnen 32 Bit Wörter zu füllen kannst du den Sting von rechts nach links auflösen
Naja, ich habe bei mir ein long-Array, aber insgesamt gibt es ja einen Typ für 64 it, für 256 nicht.
Aber danke schonmal für diesen Tipp...
Ich weiß aber leider noch nicht, wie ich meine 8 longs mit den Daten füllen soll!Gibst du mir noch einen Denkanstoß?
MfG MAV
-
-Nimm ne 32 Bit Variable
-beginne ganz rechts in deinem String
-wandle Ziffer für Ziffer um solange bis der Wert 2^16 übersteigt
-Numm den Teil der in eine 16 Bit int passt in eine temp variable
-damit hast du deine erst 16 Bit ziffer
-nimm den Überlauf und addiere zu dem die nächsten Ziffern bis du wieder 16 Bit überschreitest
- extrahier auf gleiche art und weise wie oben den 16 Bit wert.
- kombiniere die beiden 16 Bit werte zu einer 32 Bit zahl, damit hast du deine erste von 8 32 Bitzahlen
- mach das für die nächsten seiben male genauso.Der Grund warum ich nur auf 16 Bit aufsummiere in der 32 Bit zahl ist das ich den Überlauf nicht verlieren darf.
Ich hoffe es hilft
-
Ja, vielen Dank, irgendwie doof, da hätt ich auch drauf kommen müssen
Hm, aber was meinst du denn jetzt mit Überlauf?
MfG MAV
-
Ach, ich versteh schon, hab jetzt beim Ausprobieren mit 32 Bit den Faden geschnappt.
Danke nochmals!
-
An der Lösung wäre ich auch interessiert, ich brauchs zwar nicht aber interessant isses.
Vielleicht kann man ea ja so anlegen das man das auch mit noch mehr Stellen machen kann.
-
Das stellt sowieso kein Problem dar, das auf 1 KiloBit oder sonstwiehoch zu erweitern.
Nur gibt es jetzt schon einige Probleme:2000000000
lTemp += Ziffer * Zehner;
Da die Zahl 0 bleibt, kommt er erst dann über pow(2,16), wenn er die 2 hinzugefügt hat und dann ist es riesig
Sollte aber gehen, nur reicht es nicht, den Überlauf einfach hinzuzuaddieren, das wäre dann ja die Gesamtzahl auf verschieden shorts aufgeteilt, ich will das aber sozusagen als ein Ding handhaben.
MfG MAV
-
Dann zähl halt die Potenz mit und nimm das weiteres Kriterium um eine Teilzahl als gefüllt zu definieren und somit auf die nächste Teilzahl zu wechseln.
-
Ja, geht wohl nicht anders.
Aber wie soll ich den Rest dazumachen?
Wenn die ersten 16 Bit gefüllt sind kann ich ja net einfach pow(2,16) abziehen, denn dann habe ich zwar diese Werte, aber das alles in...
hm villeicht >> 16
-
Schon mal was von Bitweisem und und oder gehört, das sollte hier helfen.
-
Ich kriege es einfach net gebacken, obs am Wetter liegt, an meiner Dummheit oder sonstwas:
DQL::DQL(std::string str) { (*this) = 0ul; unsigned long lTemp = 0ul; int nCount = 1; int nPart = 0; bool bPart1 = true; for(std::string::iterator it = str.end() - 1; it >= str.begin(); --it) { lTemp += charToDigit(*it) * nCount; nCount *= 10; if(lTemp > pow(2, 16)) { if(!(lTemp > pow(2,16)) && nCount > pow(2,16)) lTemp = nCount; if(bPart1) { bPart1 = false; m_dql.m_l[nPart] = static_cast<int>(pow(2, 16)); } else { bPart1 = true; m_dql.m_l[nPart] |= (static_cast<int>(pow(2, 16)) << 16); ++nPart; } nCount = 1; m_dql.m_l[nPart] += lTemp - static_cast<int>(pow(2,16)); lTemp = 0; bit(lTemp); } } if(bPart1) m_dql.m_l[nPart] = lTemp; else m_dql.m_l[nPart] |= (lTemp << 16); }Wenn ichs schon nicht alleine schaffe, will ichs jetzt wenigstens wissen, WAS daran falsch ist.
Mfg MAV
-
Im Übrigen bleiben die alten Bits nicht einfach so verändert...
Denn da die Zahl 2^16 übersteigt sind die ersten 16 Bit ja: 1111 1111 1111 1111
Und wenn man sich die Zahl, über 2^16 seiend, binär anschaut, dann sieht man deutlich, dass die ersten 16 Bits nicht alle 1 sind.
Mfg MAV
-
Da du operator* und operator+ vermutlich schon hast, würde ich einfach das normale (imho?) Verfahren anwenden:
DQL::DQL(const std::string& str) { (*this) = 0; for (unsigned i = 0; i < str.size(); ++i) { *this *= 10; *this += str[i] - '0'; } }Bietet sicherlich viel Platz für Optimierung, aber da String->DQL vermutlich nicht viel in kritischem Code vorkommt, warum nicht?
-
Argh...
Naja, ich habe + schon, * nicht.
Aber du hast natürlich Recht, was für ein Quatsch.MfG MAV
-
Ich brech die Klasse ab, string kommt nämlich sehr wohl oft vor, jedes Mal bei der Initialisierung.
Und außerdem ist die Klasse lahm wie sau:
1 Mrd. * 1. Mrd = 10 Stunden Rechenzeit
-
Wenns dich interessiert: Ich habe mal eine Klasse für grosse Integer geschrieben. Kannst dir ja mal anschauen: http://www.acid-code.ch/~samuel/BigInt.zip