Limitless Int - Sinnvoll ?

[5cript]

Ich hab eine Klasse geschrieben, bei der man mit Zahlen rechnen kann die *fast* Grenzlos große Ganzzahlen behandeln kann und damit rechnen.
Die Ausgabe ist als std::string.
Ich arbeite momentan an der Substraktion.

Leider muss die Grenze vorher definiert werden, dynamisch hab ich das noch nicht hinbekommen.

1. Brauch man sowas überhaupt ? (hat einfach spaß gemacht sowas zu basteln)
2. Könnt ihr mir helfen die Initialisierung der Größe die man vorher machen muss rauszukriegen ?

Hier Code:
Klasse:

class Limitless
{
	private:
		std::vector <int> thousands;
		int len;
		int Overflow;
	public:
		void Initialise(int MaxLength);
		void AddInteger(long int Value);
		void Substract(long int Value);
		std::string OutputValue(bool dotted);
		// math funktion
		void MultiplyWithInteger(long int Value);
		void DivideTrough(long int Value);

	Limitless& operator += (long int Val)
	{
		AddInteger(Val);
	}
        Limitless& operator *= (long int Val)
	{
		MultiplyWithInteger(Val);
	}
	Limitless& operator /= (long int Val)
	{
		DivideTrough(Val);
	}
	Limitless& operator ++ ()
	{
		AddInteger(1);
	}
};

Initialisieren:

void Limitless::Initialise(int MaxLength)
{
	MaxLength++;
    thousands.reserve(MaxLength*3);
	int i = 0;
	while (i < MaxLength)
		{i++;thousands.push_back(0);}
	len = MaxLength;
}

Addieren

void Limitless::AddInteger(long int Value)
{
	thousands[0] += Value;
	long int i = 0;
	while (true)
	{
		if (thousands[i] > 999)
		{
			if (i <= len)
			{
            	if (thousands[i+1] > 999)
				{
					i++;
				}
				while (thousands[i] > 999)
				{
					thousands[i] -= 1000;
					thousands[i + 1] += 1;
				}
			}
			else
				Overflow = 2;
		}
		else
        	break;
	}
}

Die Ausgabe ist ja jetzt nich so wichitg.

[drakon]

Das kann man schon brauchen. Daher gibt es auch gute Lösungen bereits:
http://www.gmplib.org/

Ich verstehe dein Problem nicht so ganz.

Subtraktion ist eigentlich recht einfach. Du musst du die Addition richtig machen. Wenn die Addition nämlich das addieren von positiven und negativen Zahlen korrekt handhabt lässt sich die Subtraktion mit 2 Zeilen implementieren.

[5cript]

drakon schrieb:

Ich verstehe dein Problem nicht so ganz.

Subtraktion ist eigentlich recht einfach. Du musst du die Addition richtig machen. Wenn die Addition nämlich das addieren von positiven und negativen Zahlen korrekt handhabt lässt sich die Subtraktion mit 2 Zeilen implementieren.

Die Subtraktion ist nicht das Problem, zumindest noch nicht.
Das Problem ist, dass es immer noch zu Überläufen kommen kann, wenn man die Eigene Grenze überschreitet. Diese sollte sich dann automatisch heben.

(Aus der Addition)

if (i <= len)
            {
                if (thousands[i+1] > 999)
                {
                    i++;
                }
                while (thousands[i] > 999)
                {
                    thousands[i] -= 1000;
                    thousands[i + 1] += 1;
                }
            }
            else
                Overflow = 2;

Ich muss den vector weiter vergrößern, da wo jetzt Overflow = 2; steht, und die Abrage | if(i <= len) muss anders gestaltet werden.

Ich suche:

1. Eine Funktion mit der ich die Größe eines Vectors erhalte

Weiter erhalte ich noch folgendes Problem:
diese Länge kann ja nur als int ausgegeben werden, doch der hat wiederum eine Grenze. (Aber das ist dann sicher schon wieder nebensächlich, der Datentyp wäre trotzdem bei weitem größer als andere)

[SideWinder]

Sieh' dir die Doku von std::vector an, da findest du alle Methoden die du benötigst.

MfG SideWinder

[unskilled]

void Limitless::AddInteger(long int Value)
{
    long to_add = Value;
    for(std::vector<int>::iterator i(thousands.begin()), e(thousands.end()); i != e; ++i)
    {
      *i += to_add;

      if(*i < 1000)
        continue;

      to_add = *i/1000;
      *i %= 1000;
    }

    if(to_add == 0)
      return;

    //ggf. noch rollback-fähig machen, falls bad_alloc fliegt
    thousands.push_back(to_add);    
}

so siehts doch irgendwie toller aus, oder?

einziges problem: kannst du eben nicht als minus verwenden - aber das konnte deine bisherige lösung ja auch nicht...

bb

edit: aus dem continue kannst du so gar auch ein return machen, wenn du dir sicher bist, dass der vector davor in ordnung(alles < 1000) war.

[volkard]

to_add heißt carry und kann nur ein bit fassen und % gibts in der Schleife nicht und limitless klingt nach unlimited, aber ich würde übliche Namen bevorzugen wie NotReallySmallInt.

[5cript]

volkard schrieb:

aber ich würde übliche Namen bevorzugen wie NotReallySmallInt.

wie wärs mit "long long long long long long int" ? xD