Aber aus einem mir unbekannten Grund ist die Zahl immer 2 kleiner als der String. Hab keine lust, einfach + 2 zu addieren, weil ich den eigentlichen Fehler finden will. Danke im Voraus.

for(int i = (Eingabe.size()-1); i >=0; i--)
{
     Zahl = Zahl + (Eingabe[i]-'0') * pow(10,(Eingabe.size()-1-i)); 
}
cout << Zahl;

Was tut das?

Edit: Ach so das wird eine atol-Funktion.

ruhig_brauner: Hast du Zahl mit 0 initialisiert?

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/

*gähn

Ganz vorbildlich mit 0 initialisiert. Der String enthält auch nur Zahlen, wird vorher kontrolliert.

PS. Mir gings darum, meinen Fehler zu finden. thx trozdem

Ich hab die beiden Teile mal geteilt. Die Ziffer und die Potenz.
Jetzt wird in der Schleife ausgegeben, was die aktuelle Ziffer und was die aktuelle Potenz ist, dabei entsteht kein Fehler. Alles ist richtig.

Sobald aber die Zahl berechnet wird, schlieft sich irgendwo ein Fehler ein.

Bsp:
im String ist 1234
Ziffer = 4, Potenz = 1
Ziffer = 3, Potenz = 10
Ziffer = 2, Potenz = 100
Ziffer = 1, Potenz = 1000

Zahl += Ziffer * Potenz

Zahl = 1232

Wenn ich nun stück für stück gucke, was zur Zahl hinzuaddiert wird, kommt manchmal son quatsch raus:
4
29 (Anstatt 30)
200
999 (Anstatt 1000)

versteht das jemand?

Meine Vermutung geht in Richtung Präzision der pow-Funktion.
Bist du daran gebunden?

MfG f.-th.

Die Vermutung mit Ungenauigkeit hatte ich auch schon, aber das Programm gibt mir die pow-Ergebnisse ja mit 1, 10, 100 u.s.w ganz normal aus. Erst die Multiplikation der beiden ganzen Zahlen bringt den Fehler rein.

34 - 34
345 - 342
3546 - 3541
36544 - 36536

Deine Zahlen machen das ganze nur noch ungenauer.

MfG f.-th.

schreib dir selbst eine potenzfunktion für long

hätte halt nicht gedacht das pow da ungenau ist, auch wenn bloß int-Werte eingehen

Jetzt sieht der Quelltext wegen den ganzen Kontrollen zwar ein wenig unhübsch aus, aber es funktioniert. Wegen sowas übt man ja.

Pi hat dir ja schon einen anderen Weg gezeigt.

Dein Ansatz ohne #include <cmath> und pow:

for(int i = 0; i < (Eingabe.size()); i++)
	{
		int zpotenz = 1;
		for(int j = 0; j < i; j++)
			zpotenz = zpotenz * 10;
		Zahl = Zahl + (Eingabe[Eingabe.size() - 1 - i]-'0') * zpotenz;
	}

Das geht wahrscheinlich noch eleganter.

for( int i = 0; i < Eingabe.size(); ++i )
{
	Zahl = ( Zahl << 3 ) + ( Zahl << 1 ) + Eingabe[i] - '0';
}

Oder sogar ganz ohne Multiplikationen:

for( int i = 0; i < Eingabe.size(); ++i )
{
	Zahl = ( Zahl << 3 ) + ( Zahl << 1 ) + Eingabe[i] - '0';
}

Das ist allerdings ziemlich unsinnig, weil es deutlich langsamer sein kann. Auf einem AVR atmega16 zum Beispiel kostet eine Multiplikation genau 2 Takte. Ein Shift um 3 Positionen nach links kostet 3 Takte, ein Shift um eine Position nach links 1 Takt und die zusätzliche Addition nochmal 1 Takt. Insgesamt hat man hier also 5 Takte für deine Lösung gegenüber 2 Takte, wenn man einfach direkt mit 10 multipliziert.

Solche Optimierungen überlässt man besser dem Compiler.

int main()
{
	const char* nr = "1336543215";

	const int maxNum = 100000000;

	{
		StopWatch w; // nutzt den PerformanceCounter
		w.Start();
		for(int i=0;i<maxNum;++i)
		{
			int k = atoiReano(nr);
			if(k!=1336543215)
				cout << "unmoeglich\n";
		}
		w.Stop();
		cout << w.GetTime() << "ms\n";
	}
	{
		StopWatch w;
		w.Start();
		for(int i=0;i<maxNum;++i)
		{
			int k = atoi(nr);
			if(k!=1336543215)
				cout << "unmoeglich\n";
		}
		w.Stop();
		cout << w.GetTime() << "ms\n";
	}
}

Ausgabe:

1.01927ms
5.02301ms

Für mein System ist das eindeutig, von Unsinn kann da keine Rede sein.

Putzfrau gesucht
10 € / Stunde

for(int i=0;i<maxNum;++i) 
        { 
            int k = atoiReano(nr); 
            if(k!=1336543215) 
                cout << "unmoeglich\n"; 
        }

das das rausoptimiert werden kann, erkennt auch der unfähigste compiler Oo

Reano: 20ms
Pi: 40ms
Standart: 90ms

Ausgabe:

1.01927ms
5.02301ms

Für mein System ist das eindeutig, von Unsinn kann da keine Rede sein.

Hast du im generierten Assembler-Code geprüft, dass deine Schleife nicht einfach komplett rausoptimiert wurde?

das das rausoptimiert werden kann, erkennt auch der unfähigste compiler Oo

phyax hat ja schon einen Link gepostet, während ich mir noch den asm-Output angeschaut habe. 20% der Zeit von atoi passt ja auch. Compiler war VC 9, win64 und x64-Code natürlich im Releasemodus, Schleifen nicht rausoptimiert (VC tut sich diesbezüglich immer schwer damit).

Update:

0.770659s  Reano
5.03864s   atoi
1.17046s   Pi
123.285s   stringstream

Mit dem alten g++ 4.4

1.0659s
5.07371s
1.09504s
105.263s

Ich hatte erwähnt, Zeichenfolgen zufällig zusammenzustellen, aber auch bei statischen Zeichenketten optimieren die Compiler nichts weg.