String -> Zahl in einzelne Bits < übersteigend double

[PAD]

-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

[Mis2com]

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

[Mis2com]

Ach, ich versteh schon, hab jetzt beim Ausprobieren mit 32 Bit den Faden geschnappt.

Danke nochmals!

[PAD]

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.

[Mis2com]

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

[PAD]

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.

[Mis2com]

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

[PAD]

Schon mal was von Bitweisem und und oder gehört, das sollte hier helfen.

[Mis2com]

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

[Mis2com]

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

[operator void]

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?

[Mis2com]

Argh...

Naja, ich habe + schon, * nicht.
Aber du hast natürlich Recht, was für ein Quatsch.

MfG MAV

[Mis2com]

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

[SeriousSam]

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