String -> Zahl in einzelne Bits < übersteigend double

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

String -&gt; Zahl in einzelne Bits &lt; übersteigend double

String -> Zahl in einzelne Bits < übersteigend double