struktogramm & for - Schleife

[pear]

Hallo alle zusammen Ich habe gestern fleißig eine Theorie entwickelt ( für die zählergesteuerte Schleife ) : Ich lasse den Compiler von startwert bis endwert fleißig zählen. Mit der schrittweite sage ich ihm , in welchen Schritten er zu zählen hat. Nebenbei führt der Compiler bei jeder Zählung den A.block aus. Den A.block führt er logischerweise so lange aus , so lange er zählt. Leider habe ich das anhand der zählergesteuerten Schleife in Struktogrammen geschrieben. Danach habe ich mir die for-Schleife angesehen & gemerkt , dass meine ganzen Mühen umsonst waren : for(i=1; i<=5; i ) Meine halbwegs richtige Erklärung dazu : Der compiler zählt solange , solange i<=5 ist ( stimmt auch ) --> wenn i = 6 ( !<= 5 ) --> Compiler hört auf zu zählen. Nur dieser Teil meiner Theorie : Compiler führt A.block so lange aus , so lange er zählt stimmt nicht... Wenn ich jetzt schreibe : solange der Compiler zählt und die Bedingung wahr ist , dann kann ich meine Theorie vom Struktogramm in den Mülleimer schmeißen. Ich brauche wirklich eine logische Erklärung. Das Problem ist : Ich brauche immer eine log. Erklärung, sonst kann ich nicht ruhig schlafen.

[supertux]

schreibst du auch deinen Code so, wie du deinen Text schreibst? Wenn ja, dann meine Güte, das kann man nicht lesen! Schon mal von Absätzen (einfach <ENTER> drücken) gehört?

Sorry, dass ich hier meckere, aber wenn du Hilfe von uns willst, dann musst du wenigsten so schreiben, dass man es durchlesen kann.

[hj]

Hallo alle zusammen

Ich habe gestern fleißig eine Theorie entwickelt ( für die zählergesteuerte Schleife ) :

Ich lasse den Compiler von startwert bis endwert fleißig zählen.
Mit der schrittweite sage ich ihm , in welchen Schritten er zu zählen hat. Nebenbei führt der Compiler bei jeder Zählung den A.block aus.
Den A.block führt er logischerweise so lange aus , so lange er zählt.

Leider habe ich das anhand der zählergesteuerten Schleife in Struktogrammen geschrieben.
Danach habe ich mir die for-Schleife angesehen & gemerkt , dass meine ganzen Mühen umsonst waren :

for(i=1; i<=5; i ) Meine halbwegs richtige Erklärung dazu :
Der compiler zählt solange , solange i<=5 ist ( stimmt auch ) --> wenn i = 6 ( !<= 5 ) --> Compiler hört auf zu zählen. Nur dieser Teil meiner Theorie : Compiler führt A.block so lange aus , so lange er zählt stimmt nicht... Wenn ich jetzt schreibe : solange der Compiler zählt und die Bedingung wahr ist , dann kann ich meine Theorie vom Struktogramm in den Mülleimer schmeißen. Ich brauche wirklich eine logische Erklärung. Das Problem ist : Ich brauche immer eine log. Erklärung, sonst kann ich nicht ruhig schlafen.

jkhkjkjhh

[Th]

Ich denke, du meinst folgende Schleife (mit i++, weil sonst hättest du eine Endlosschleife):

for(i=1; i<=5; i++)
  A();

Zuersteinmal zählt nicht der Compiler, sondern der Prozessor (wenn das Programm dann läuft), denn der Compiler übersetzt es nur.

Und zur Erklärung:
Du kannst dir diese Schleife auch alternativ mit der while-Schleife erzeugen lassen:

i=1;
while(i<=5)
{
  A();
  i++;
}

Am Anfang wird die Schleifenvariable genau einmal initialisiert, und danach wird die Bedingung überprüft (sog. kopfgesteuerte Schleife).
Solange die Bedingung erfüllt ist, wird der Block ausgeführt (die Funktion A() aufgerufen) und danach dann die Zählvariable um 1 erhöht.
Nun wird wieder die Bedingung abgefragt und solange diese immer noch wahr ist, wird wieder der Block ausgeführt usw.
Nur wenn die Bedingung falsch ist (d.h. dies kann auch schon zu Beginn sein, wenn du dort "i < 1" stehen hättest oder aber i mit 10 initialisiert hättest), wird die Anweisung ausgeführt, welche hinter der Schleife (Blockklammer) folgt.