Schleifen
 

Was sind Schleifen?
Schleifen werden dazu verwendet, eine immer wieder vorkommende Sequenz von Befehlen mehrfach auszuführen. Dazu bedient sich die Schleife entweder eines Zählers oder einer bereits deklarierten Bedingung. Diese Bedingungen oder Zähler werden dann so lange abgearbeitet, bis sie erfüllt wurden und somit nicht mehr wahr sind.
In diesem Kapitel wollen wir uns unter beiden C verwendeten Schleifen-Befehlen widmen.
 
 
 

 For-Schleife
 

Eine For-Schleife wird dazu verwendet, einen angegebenen Anfangswert so lange zu verändern, bis schließlich eine Bedingung erfüllt wurde.
Hier ein kleines, aber aussagekräftiges Beispiel:
 
 

 #include <stdio.h>

     main()
      {
          int erste;
          int zweite;
          for (erste = 1 ; erste <= 9 ; erste = erste+1)
               {
                   for (zweite = 2 ; zweite <= 10 ; zweite = zweite +1)
                   printf("%ld*%ld=%ld ", erste , zweite, zweite *erste );
                   printf(" \n");
               }
          }
 
 

Funktionsweise:

Mir dieser Schleife generieren Sie das "Ein mal Eins".
Das Programm deklariert am Anfang unsere Variablen "erste" und "zweite", bis er dann schließlich die erste Schleife erreicht.
Dort fängt er bei Zählerstand erste=1 und führt die Schleife aus. Diese wird durch zwei Klammern
gekennzeichnet, was aber bei bestimmten Voraussetzungen entfallen kann. Dazu aber erst später.
Als nächstes trifft unsere Schleife auf eine weitere Schleife, die sofort ausgeführt wird.
Das Programm beginnt die zweite Schleife ab dem Wert 2 zu durchlaufen. So wird bei jedem Durchlauf dieser Schleife der Zählerstand um 1 erhöht (zweite = zweite +1), bis schließlich die vorgegebene Zahl (in unserem Fall ist es 10) erreicht wird.
Da wir keine Klammern gesetzt haben, wird bei jedem Durchlauf der Schleife nur der direkt unter der Schleife stehende Befehl (printf )ausgeführt und zwar jedesmal, wenn die Schleife "Zwei" durchlaufen wird.
Durch diese Technik können wir unsere oberste Zeile der "Ein mal Eins"-Tabelle berechnen.
Das Programm verläßt die Schleife "Zwei", macht einen Absatz (printf(" \n");) und kehrt zurück zur ersten Schleife.
In dieser wird der Zählerstand wieder um einen Zähler erhöht und der Schleifenkern ausgeführt.
In unserem Falle ist es wieder unsere zweite Schleife, die wiederrum von 2 bis 10 zählt und unsere zweite Zeile berechnet.
Dieser Vorgang wird so lange ausgeführt, bis unsere erste Schleife den Wert 10 erreicht hat.
 
 
 

 while-Schleifen
 

Eine weitere Möglichkeit, Schleifen unter Linux zu bilden, ist der Einsatz der while-Schleife.

Bei dieses Schleifenart unterscheiden wir zwei Sorten:

 "while"
 "do-while"

Eine while-Schleife ist ähnlich unserer For-Schleife aufgebaut.

Die Syntaxbeschreibung solch einer Schleife sieht folgendermaßen aus:

 while  (Bedingung)
  {
  Schleifenanweisung
  }

Diese können daher ähnlich einer For-Schleife, Programme zeitlich ablaufen lassen und bedingungsgesteuert ausführen.
Um Ihnen ein Beispiel zu zeigen, versuchen wir das obengenannte Programm in einer while-Schleifenart zu realisieren. Der Quellcode sieht dann folgendermaßen aus:
 
 

        #include <stdio.h>

        main()
          {
              int erste = 0;
              int zweite = 1;
              while (erste++ <= 8)
               {
                   while (zweite++ <= 9)
                   printf("%ld*%ld=%ld ", erste , zweite, zweite *erste );
                   printf(" \n");
                   zweite = 1;
               }
          }
 
 
 

Funktionsweise:

Wir deklarieren als erstes unsere Variablen ťersteŤ und ťzweiteŤ. Dazu belegen wir diese mit einem Wert, da im späteren Verlauf kein Wert mehr zugewiesen wird.
Unser Programm befolgt weiter seinen Weg und führt deshalb die erste Schleife aus.
In dieser wird als erstes unsere Variable ťerstesŤ um einen Zähler ( erste++ ) erhöht und dann nach Erfüllung der Bedingung überprüft ( <=8 ). Da bei erstem Durchlauf diese noch nicht erfüllt ist, führt das Programm die sich in eckigen Klammern befindende Anweisungsschleife aus.
Dort wird ebenfalls die Variable ťzweiŤ um einen Zähler erhöht ( zweite++ ) und die Bedingung überprüft ( <=9 ). Da diese auch noch nicht erfüllt ist, führt das Programm den nächsten Befehl aus ( printf... ).Nachdem dies überprüft wurde, kehrt die Schleife wieder zurück und erhöht noch einmal den Wert von ťzweiteŤ um einen Zähler. Dieser Vorgang wird so lange ausgeführt, bis die Anweisung <=9 wahr ist.
Nachdem dies geschehen ist, setzt das Programm seinen Lauf fort und ťproduziertŤ einen Absatz ( printf(" \n"); ).

Nun müssen wir wieder die Variable ťzweiŤ zurücksetzen, damit beim nächsten Durchlauf das Programm von vorne rechnet und nicht die Zahl weiter erhöht.
Da unsere erste Schleife noch nicht erfüllt wurde ( <=8 ) kehrt das Programm wieder zur Schleife ťeinsŤ zurück und erhöht wieder den Wert der Variablen ťeinsŤ um einen Zähler, überprüft die Abhängigkeiten und führt wieder die Schleife ťzweiŤ aus.
Dort wird wieder von vorne, unsere zweite Zeile berechnet, da wir zuvor den Wert der Variable  ťzweiŤ zurückgesetzt haben. Dadurch wurde ermöglicht, daß Schleife ťzweiŤ wieder von vorne rechnen kann.
 

Dieser Vorgang wird so lange wiederholt, bis die Schleife ťeinsŤ erfüllt wurde ( erste++ <= 8 ) und somit das Programm beendet werden kann.
Um ein wenig Einblick der Funktionsweise des Programmes zu gewinnen, versuchen Sie, die Variablen etwas zu verändern und beobachten Sie dann, welche Folgen es für den Ablauf des Programmes haben wird.
Wenn Sie z.B. den Wert der ersten Schleife von 8 auf 18 setzen, dann werden Sie beobachten können, daß ihr Programm nicht wie im obengenannten Beispiel bis 9 rechnet, sondern erst bei 19 halt macht.
 
 
 
 

Nächster Themenbereich:

Funktionen und Klassen