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.

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.

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)

MfG SideWinder

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.

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

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