for (int i = 0; i < 4; i++)
  {
        (zahl1 - zahl2);
        i++;
  }

Diese Schleife soll 4 mal durchlaufen. Pro Durchlauf soll Zahl1 - Zahl2 gerechnet werden. Am Ende will ich Zahl1 ausgeben.
Als Beispiel mit richtigen Zahlen:
Zahl1=8 und Zahl2= 1
Nach dem Durchlauf der Schleife soll Zahl1 dann den Wert 4 haben. Den (8-1) und das 4 mal wiederholt ergibt ja 4.
Bei mir sind die Zahlen keine integer sonder float, da es sehr große Zahlen sind. Ich erhalte komischerweise als Ergebnis immer etwas wie 1.61747e+009.
Warum erhalte ich keine "normale" Zahl wie z.B. 1023923 oder so?
Hoffe ihr könnt mir helfen !

for (int i = 0; i < 4;)
  {
        (zahl1 - zahl2);
        i++;
  }

Trotzdem kommts nichts bei raus. Wenn die Zahl1 z.B. den Wert 1019 hat und die Zahl2 den Wert 1010 kommt nichts bei raus, bzw. nichts richtiges. Dann wird mir 1019 angezeigt.

habs jetzt so:

for (int i = 0; i < 4;)
    {

        ergebnis = (zahl1-zahl2);
        i++;
    }

Wenn nur 1 Durchlauf stattfindet klappt es, bei mehreren Durchläufen kommt wieder so ein "komischer" Wert raus.

Also. Man gibt Zahl1 in das Programm ein. Z.B. "10". Das wird als String gespeichert. Die Stringlaenge ist 2. Also soll die Schleife 2 mal durchlaufen. Zahl1 und Zahl2 habe ich dann, weil sie eigentlich ein String waren, zu einem float konvertiert.

string zahl1, zahl2;
float zahl1, zahl2i, ergebnis;
.....

zahl1i = atoi(zahl1.c_str());
zahl2i = atoi(zahl2.c_str());
......

    for (int i = 0; i < zahl1.length();)
    {

        ergebnis = (zahl1i-zahl2i);
        i++;
    }

Habe mein Problem erkannt, wenn zahl1, zahl2i und ergebnis wieder zu integer gemacht werden gehts! trotzdem thx!

Habe das i++ in der for Schleife entfernt.

Bitte im Rumpf und nicht in der for-Anweisung entfernen das ist mehr als ungewöhnlich:

#include <iostream>

int main()
{
    float zahl1 = 8.0;
    float zahl2 = 1.0;
    for (int i = 0; i < 4; ++i)
        zahl1 -= zahl2;
    std::cout << zahl1;
}

Um es für dich genauer zu machen:
for(<1>;<2>;<3>)

1. Initialisierung, wird einmalig zum Begin ausgeführt
2. Abbruchbedingung, wird vor jedem Durchgang geprüft
3. Ausdruck der am Ende jedes Schleifendurchganges ausgeführt wird

cu André

1019101710201021 - 101010101010
und das in der Schleife, also in dem Fall läuft die Schleife 3 mal durch, kommt bei mir -1765712469 raus, was irgendwie überhaupt nicht passt.

werde es mal mit deiner for schleife probieren!

**/edit:
Es kommt immer noch nichts brauchbares bei raus.
so soll z.b. 102010201020 - 10101010 = -1.08922e+009 sein
**

[red] Ok der Fehler liegt darin das meine Strings nicht richtig zu float konvertiert werden. zahl1i = atoi(zahl1.c_str()); was ist daran z.b. falsch?
zahl1 hat im string z.b. 10101010 und der schluesselwert ist 1.0101e+007 obwohl dieser auch 10101010 sein sollte![/red]

Die physikalische Größe des Strings ist die Anzahl an gespeicherten Zeichen ohne eventuell vorhandenen Null-Terminator (Strings müssen ihre Daten nicht mit '\0' abschließen, außer zur Ausgabe durch c_str()). Die Größe kann über die Methoden size() und length() abgefragt (beide Methoden sind gleichwertig) und über resize(len,c) gesetzt werden - letzteres schneidet Zeichen am Ende ab bzw. füllt den String mit Kopien von c (Defaultwert ist '\0') auf, um die nötige Größe zu erreichen. Außerdem beeinflussen viele Stringmethoden, z.B. replace(), append() oder erase(), indirekt auch die Größe des Strings.

Die Kapazität des Strings ist die Zeichenzahl, die ohne Reallokation eingetragen werden kann. Sobald die Größe die Kapazität überschreitet, wird der gesamte Stringinhalt in einen neuen, größeren Block umkopiert und der alte Speicherblock freigegeben. Die Kapazität kann über die Methode capacity() abgefragt und über die Methode reserve(size) gesetzt werden. Im Gegensatz zu Vektoren, deren Kapazität NIE verkleinert wird, darf ein String auch in einen kleineren Speicherblock umziehen (allerdings nur auf Anforderung) - insbesondere bewirkt ein reserve() ohne Parameter eine Verkleinerung der Kapazität auf die aktuelle Größe.

Anmerkung: Es ist im Standard nicht garantiert, dass der String seine Kapazität verringern muss - er darf eine entsprechende Anforderung auch ignorieren. Umgekehrt ist es jedoch nicht erlaubt, dass der String aus eigenem Antrieb die Kapazität verkleinert. Der einzige Weg, garantiert die Kapazität eines Strings zu veringern, ist die Verwendung des sogenannten "swap-Tricks":
C/C++ Code:
void shrink(string& str)
{
string nstr(str.begin(),str.end());
str.swap(nstr);
}
C/C++ Code:
void shrink(string& str)
{
string nstr(str.begin(),str.end());
str.swap(nstr);
}
C/C++ Code:
void shrink(string& str)
{
string nstr(str.begin(),str.end());
str.swap(nstr);
}

wie müsste das jetzt aussehen wenn ich z.b. einem string namens "zahl" die größt mögliche größe geben will?

mfg

18446744073709551616 // maximal Darstellbare Wert von long long
888888888888888888
30303030303030303030 // das ist zu gross

Und wie kann ich des alles noch "größer" machen?^^ Oder geht das nicht?

Das geht nicht. Was du machen könntest eine eigene Zahlenklasse mit entsprechenden Operatoren zu schreiben, oder nach einer entsprechenden Bibliothek suchen.

cu André