Stellen Sie sich vor, Sie haben einen Array, xvalues[10000], angelegt und sollen diesen nun mit Werten füllen. jetzt zu schreiben

xvalues[0] = 0;
xvalues[1] = 1;
xvalues[2] = 2;
.
.
xvalues[9999] = 9999;

geht natürlich auch, aber es sollte doch auch eine einfachere Möglichkeit geben. Es gibt sogar drei verschiedene:

• die for Schleife
• die while Schleife
• die do - while Schleife

1. for Schleife

die generelle Form ist:

for ( Initialisierung; Bedingung; Schrittweite )
{

Anweisungen;

}

Jetzt zur Praxis, bei einer for Schleife brauchen wir eine Laufvariable, z.B.

int i;

Schleifenlaufvariablen haben häufig Namen wie i, j, k oder so. Dies liegt einerseits daran, das dies so schön kurz ist und zum zweiten kommt es noch von good old FORTRAN. In FORTRAN sind alle Variablen die mit den Buchstaben i bis n anfangen per default impliziet integer, es sei denn, man gibt den Typ direkt an. Ich glaube mich zu erinnern, dass deshalb mal eine Mars Sonde perdu gegangen ist, weil der FORTRAN Programmierer eine Variable die eigentlich eine reelle Zahl war, mit einem Buchstaben zwischen i bis n anfangen lies.

So und jetzt die erste Schleife, schreiben Sie bitte in Ihrem Compiler ein kleines main Programm und probieren Sie folgendes aus:

for( i = 0; i < 10; i++)
   printf("i: %d\n", i);

Wenn es nur eine Anweisung gibt, die bei jedem Schleifendurchlauf ausgeführt werden soll, kann man sich die geschweiften Klammern auch sparen. Kurz zur printf Anweisung (print formatet, kriegen wir später) : hier wird auf die Konsole geschrieben und zwar erst "i: "und dann die Zahl die i gerade hat und dann das Return-Zeichen "\n" .

Zuerst wird die Schleifenvariable initialisiert: i = 0;
Dann wird die Laufbedingung festgelegt: i < 10; wird diese falsch, bricht die Schleife ab.
Zum Schluß wird die Schrittweite angegeben: i++

Wenn Sie das Programm laufen lassen sollten Sie folgenden output erhalten:

i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9

Mit diesen Parametern kann man jetzt spielen:

for( i = 10; i > 0; i--)
   printf("i: %d\n", i);

ergibt folgenden output:

i: 10
i: 9
i: 8
i: 7
i: 6
i: 5
i: 4
i: 3
i: 2
i: 1

 

for( i = 0; i < 1000; i += 100)
   printf("i: %d\n", i);

ergibt folgenden output:

i: 0
i: 100
i: 200
i: 300
i: 400
i: 500
i: 600
i: 700
i: 800
i: 900

for( i = 1000; i > -1; i = i - 100)
   printf("i: %d\n", i);

ergibt folgenden output:

i: 1000
i: 900
i: 800
i: 700
i: 600
i: 500
i: 400
i: 300
i: 200
i: 100
i: 0

Man kann auch mehrere Variablen im Schleifenkopf initialisieren, deren Laufbedingungen abfragen und deren Schrittweite festlegen:

for(i = 0, j = 100; i < 10, j < 150; i++, j += 10)
   printf("i: %d j: %d\n", i, j);

Hier wird i und j initialisert: i = 0, j = 100;
Ihre Laufbedingung wird abgefragt: i < 10, j < 150; beide Bedingungen müssen war sein.
Und ihre Schrittweite wird festgelegt: i++, j += 10
Dies ergibt folgenden output:

i: 0 j: 100
i: 1 j: 110
i: 2 j: 120
i: 3 j: 130
i: 4 j: 140

Die Schleife bricht ab, weil die Laufbedingung j < 150; falsch wird. Ob solche Konstruktionen die Lesbarkeit und Klarheit des Programms erhöhen, müssen Sie selber entscheiden, ich persönlich verwende solche Schleifen mit mehreren Laufvariablen nur sehr sehr selten.

So und jetzt wollen wir eine Schleife zur Initialisierung von Arrays benutzen:

int i, count, xvalues[10], yvalues[10], zvalues[10];
float veclength[10];

count = 0;
for(i = -10; i < 0; i++)
{
   xvalues[i + 10] = i;
   yvalues[i + 10] = count * 10;
   zvalues[i + 10] = 1000 + i;
   veclength[i + 10] = 0.0;
   count++;
}

for(i = 0; i < 10; i++)
   printf("x: %d    y: %d  z: %d   vec: %f\n", xvalues[i], yvalues[i], zvalues[i], veclength[i]);

ergibt folgenden output, bitte denken Sie kurz darüber nach und versuchen die Logik nachzuvollziehen :

x: -10    y: 0  z: 990   vec: 0.000000
x: -9    y: 10  z: 991   vec: 0.000000
x: -8    y: 20  z: 992   vec: 0.000000
x: -7    y: 30  z: 993   vec: 0.000000
x: -6    y: 40  z: 994   vec: 0.000000
x: -5    y: 50  z: 995   vec: 0.000000
x: -4    y: 60  z: 996   vec: 0.000000
x: -3    y: 70  z: 997   vec: 0.000000
x: -2    y: 80  z: 998   vec: 0.000000
x: -1    y: 90  z: 999   vec: 0.000000

Und jetzt mal einen mehrdimensionalen Array in einer dreifach geschachtelten for Schleife:

int i, j, k;
char errstrings[20][5][256];

for(i = 0; i < 20; i++)
   for(j = 0; j < 5; j++)
      for(k = 0; k < 256; k++)
          errstrings[i][j][k] = 0;

Hier wird der multi dimensionale Array of char mit Nullen initialisiert. Der output ist nicht ganz so spanned, alles ist Null.

Es ist erlaubt die Schleifenvariable im Schleifenrumpf zu verändern, ich empfehle dies auf gar keinen Fall zu tun. Man kann eigentlich darauf warten, dass es schiefgeht, die Konstruktion wird undurchschaubar und man hat immer die Möglichkeit das Problem irgendwie anders zu lösen:

int i, x[10];

for(i = 0; i < 100; i++)
{
   x[i % 10] = i; // i % 10, Sie erinnern sich an den Modulus Operator?
   i += 10; // O Gott, hier wird die Schleifenlaufvariable im Schleifenrumpf verändert, bitte tun Sie das nicht!
}
for( i = 0; i < 10; i++)
   printf("i: %d\n", x[i]);

ergibt folgenden output:

0
11
22
33
44
55
66
77
88
99

 

Und natürlich darf man Schleifen auch schachteln, also Schleifen innerhalb von Schleifen innerhalb von Schleifen... einfügen, hier ein Beispiel:

int i, j, k, k = 0;

for(i = 0; i < 5; i++)
  for(j = 0; j < 4; j++)
    for(k = 0; k < 3; k++)
      x++;

Ein paar nette Kochbücher aus dem O'Reilly Verlag, die Bücher mit den Tieren drauf: