#####____________________Die for Schleife___________________

Wenn ich Ihnen jetzt zur Aufgabe stellen würde ein Programm zu schreiben das 10x hintereinander Ihren Namen ausgeben soll werden sie es nach Ihrem Wissensstand so machen...

/*Download:for1.c*/
#include <stdio.h>

int main()
{
int i=1;

while(i<=10)
{
printf("Bond...James Bond\n");
i++; /*erhöhe i um den Wert 1*/
}
return 0;
}

Nun es gibt auch noch eine andere Möglichkeit nämlich mit einer for - Schleife. Erst mal der Syntax....

for(anweisung;bedienung;anweisung) { /*Tue was bis die Bedienung in der for-Schleife unwahr ist*/ }

Bitte beachten sie das sie in der Klammerung die Semikolons mit angeben! Wollen wir uns die for-Schleife anhand eines Programmablaufplanes ansehen...

Ändern wir unser Programm von oben um mit einer for - Schleife anstatt dem 'while'........

/*Download:for2.c*/
#include <stdio.h>

int main()
{
int i;

for(i=1; i<=10; i++)
{
printf("Bond.......James Bond\n");
}
return 0;
}

So nun sieht unser Programm schon anders aus. Wie sie sehen wird in unserer for - Schleife der Wert 'i' initialisiert und und um den Wert 1 erhöht. Nun mal alles der Reihe nach. Erst wird in unserer for - Schleife die erste Anweisung ausgeführt, nämlich die Variable 'i' mit dem Wert 1 initialisieren. Die erste Anweisung einer jeder for - Schleife auf der Welt wird nur einmal Ausgeführt !! Die Initialisierung von 'i' wird mit einem Semikolon abgeschlossen. Als nächstes wird die Bedienung überprüft ob 'i' kleiner oder gleich 10 ist. Da wir sie zuvor mit dem Wert 1 initialisiert haben ist diese Bedienung wahr und unser Programm wird im Anweisungsblock weitergeführt. Hier gibt unser Programm nun etwas auf dem Bildschirm aus. Wenn der Anweisungsblock ausgeführt wurde, springt unser Programm zu zweiten Anweisung in der for - Schleife um unsere Variable 'i' um den Wert 1 zu erhöhen. Nun ist der Wert von 'i' 2. Jetzt wird wieder unserer Überprüfung, ob die Bedienung wahr ist, durchgeführt (i<=10) , die ja jetzt wiederum wahr ist und unser Programm springt wieder in unserem Anweisungsblock gibt den Text wieder auf dem Bildschirm aus. Dann wird 'i' wieder um 1 erhöht, womit der Wert jetzt 3 ist. Wieder wird in unserer for - Schleife unsere Bedienung auf Wahrheit abgefragt............... das geht jetzt solange bis unsere Variable 'i' den Wert 11 hat. Dann ist unsere Bedienung falsch und das Programm wird nach dem Anweisungsblock weiter ausgeführt.

Auch bei unserer for - Schleife kann man wenn es nur eine Anweisung im Block gibt theoretisch auf die geschweiften Klammern verzichten...

for(i=1; i<=10; i++) printf("Bond...James Bond\n");

Zum Besseren Verständnis hier noch ein Beispiel das seine Syntax mit ausgibt wie unser Programmablauf der for - Schleife arbeitet...

/*Download:for3.c*/
#inlcude<stdio.h>

int main()
{
int i;

for(i=1; i<=10; i++)
{
printf("%d. Durchlauf : ",i);
printf("for(i=1;%d<=10; i++);\n",i);
}

printf("Der Wert von i ist jetzt grösser wie 10\n");
printf("Daher raus aus der for - Schleife\n");

return 0;
}

Unsere for - Schleife kann aber auch mehr wie nur Schleifen Dekrementieren(-1) bzw. Inkrementieren(+1).Wir können in der for-Schleife auch weitere Rechenoperationen vornehmen. Schreiben wir nun ein Programm bei dem unser Rechner eine 4-stellige Zufallszahl erzeugen soll und wir wollen die Zahl mit einer for Schleife in 4 Durchläufen herausbekommen ohne auf die Variable ala....

zahl=zurfallszahl;

...zuzugreifen.....

/*Download:for4.c*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
int i,x,y=0;
int zahl;
time_t t;

srand((unsigned) time(&t)); /*Initialisiert den Zufallszahlengenerator*/

zahl=rand()%9999; /*Zufallszahl 0-9999*/
/*printf("Zufallszahl zur Kontrolle = %d\n",zahl);*/

for(i=1; i<=1000; i*=10)
{
x=zahl%10*i;
zahl=zahl/10;
y+=x;
}

printf("Zufallszahl errechnet = %d\n",y);
return 0;
}

Das Programm mag auf dem ersten Blick komplizierter Aussehen als es wirklich ist. Mit...

int zahl=rand()%9999;

..bekommt unsere Variable 'zahl' eine Zufallszahl zwischen 0......9999. Denn Zufallsgenerator (dieses mal kein Pseudo mehr) haben wir mit...

srand((unsigned) time(&t));

...initialisiert. Durch den Aufruf von srand mit einem bestimmten Parameter (bei uns time_t von der Headerdatei time.h) kann er auf einen neuen Startwert gesetzt werden. Das soll uns jetzt aber nicht beschäftigen den dies ist ein späteres Thema.
Die Zeile....

//printf("Zufallszahl zur Kontrolle = %d\n",zahl);

dient nur zur Kontrolle ob unser Programm richtig arbeitet. Ich habe sie deaktiviert. Sie brauchen nur die zwei Schrägstriche '//' weglassen um zu kontrollieren ob der Code auch richtig arbeitet (gemeint ist damit ob die Zufallszahl auch wirklich errechnet wird). Nun zu unserer for - Schleife....

for(i=1;i<=1000;i*=10) { x=zahl%10*i; zahl=zahl/10; y+=x; }

...nehmen wir mal an es wurde die Zufallszahl '1234' erzeugt (zahl=1234;).....

1.Durchlauf

Code Berechnung

i=1; i<=1000

x=zahl%10*i; 1234%10*1 = 4

zahl=zahl/10; 1234 / 10 = 123

y+=x; 0+4 = 4

Denn Moduloperator kennen sie noch? Der gibt uns den Rest von 1234 / 10. Dann nutzen wir noch aus das der Variablen-typ 'int' keine Stellen nach dem Komma ausgeben kann womit wir mit geteilt durch 10 die letzte Stelle abschneiden. Dann Addieren wir den zuvor mit 0 initialisierten Wert von 'y' mit 'x' und erhalten den Wert 4. Dann wieder hoch zur Schleifen und .....

2.Durchlauf:

Code Berechnung

i=1; i<=1000 1*10 = 10 ; 10<=1000

x=zahl%10*i; 123 % 10*10 = 30

zahl=zahl/10; 123 / 10 = 12

y+=x; 4 + 30 = 34

3.Durchlauf:

Code Berechnung

i=1; i<=1000 10*10=100; 100<=1000

x=zahl%10*i; 12 % 10*100 = 200

zahl=zahl/10; 12 / 10 = 1

y+=x; 34 + 200 = 234

4.Durchlauf:

Code Berechnung

i=1; i<=1000 100*10=1000; 1000<=1000

x=zahl%10*i; 1 % 10*1000 = 1000

zahl=zahl/10; 1 / 10 = 0

y+=x; 234 + 1000 = 1234

Jetzt bricht unsere Schleife das Programm ab da unsere Variable 'i' jetzt nicht mehr kleiner oder gleich 1000 ist.
Danach wird unsere Zahl 1234 korrekt berechnet ausgegeben. Ich habe unser Beispiel oben mit allen Schritten durchgegangen. Auf der linken Seite der Tabellen stand der Syntax wie er im Programm steht, auf der Rechten Seite habe ich den Syntax mit Werten angegeben die die Variablen zu dem Zeitpunkt auch haben. Das sollte zur Einführung unserer for - Schleife reichen. Wir werden es eh noch in vielen Programmen begegnen.

Viel Sinn macht das Programm nicht, aber es hilft das sie ein Gefühl für die Programmiersprache C bekommen. Natürlich könnten wir uns die ganze Berechnung sparen und stattdessen denn Wert der Zufallszahl durch.....

y=zahl;

...übergeben.

Deshalb will ich noch zu einem Programm mit Sinn kommen. Beispiel wir haben 2 Integer (int) Zahlen. Eine hat den Wert 100 und die andere den Wert 3. Diese beiden Zahlen wollen wir miteinander teilen. Als Ergebnis werden wir 3 zurückbekommen. Nun wollen wir ein Funktion schreiben mit der es möglich ist das Ergebniss mit nach der Kommastelle auszugeben ohne float,double oder long double zu verwenden. Nur Integer (int) Variablen sind erlaubt......

/*Download:for5.c*/
#include <stdio.h>

/*Gibt 6 Stellen nach dem Komma aus*/
void komma(int komma, int teiler)
{
int i;

for(i=1; i<=6; i++)
{
if(komma==0)
break;

komma*=10;
printf("%d",komma/teiler);
komma=komma%teiler;
}
printf("\n");
}

int main()
{
int nenner=55,teil=10;

printf("55/10=%d.",nenner/teil);
komma(nenner%teil, teil);

printf("100/3=%d.",100/3);
komma(100%3, 3);

printf("1234/5=%d.",1234/5);
komma(1234%5, 5);

return 0;
}

Jetzt haben sie auch zum ersten mal gesehen wie nützlich der Modulo-%-Operator sein kann. Ich bin aber jetzt auch wieder ein bisschen vom Thema abgekommen. Im nächsten Kapitel erfahren sie wieder mehr zu den for-Schleifen.