Schleifen und case-Anweisungen - erweiterte Möglichkeiten zur Steuerung des Programmflusses

Die im vorherigen Kapitel beschriebene if-Anweisung und while-Schleife sind recht einfache Kontrollstrukturen. In diesem Kapitel werden wir uns einige komplexere Strukturen ansehen, die dazu beitragen können, Ihren Code zu verkürzen und die Anzahl der erforderlichen Eingaben zu verringern …

Während die while-Schleife, die wir im vorherigen Artikel gesehen haben, sehr nützlich ist, wird die for-Schleife von vielen Programmierern bevorzugt, da sie die gesamte Logik, die die Schleife steuert, an einem Ort platziert. Hier ein Beispiel:

#include <stdio.h>
void main (void)
 
{
  int a;
  for (a = 0; a < 5; a++)
  {
    printf ("a ist gleich mit %d\n", a);
  }
  printf ("a ist gleich mit %d und ich bin fertig \n", a);
}

Dies unterscheidet sich nicht allzu sehr von einer while-Schleife, aber die gesamte Steuerung für die Schleife befindet sich in den runden Klammern nach dem for-Schlüsselwort. Diese enthält drei durch Semikolons getrennte Anweisungen: in der Reihenfolge sind dies die Anfangsbedingung, der Test und das Inkrement.

a = 0 ist die Anfangsbedingung. Die Variable a wird zu Beginn der Schleife auf 0 initialisiert.

a<5 ist der Test, genau wie in einer while-Schleife. Dies wird bei jeder Iteration der Schleife überprüft, und der Schleifencode wird nur ausgeführt, wenn der Test als wahr ausgewertet wird. Sobald der Test falsch ist, wird die Ausführung nach der geschweiften Klammer am Ende des Schleifencodes fortgesetzt.

a++ ist das Inkrement. Dies ist Code, der am Ende jeder Iteration der Schleife ausgeführt wird, bevor der Test erneut ausgewertet wird. In diesem Fall wird 1 zu a hinzugefügt.

Was passiert also, wenn diese for-Schleife ausgeführt wird? Zuerst wird a auf 0 gesetzt. Der Test wird dann überprüft - ist a (das den Wert 0 hat) kleiner als 5? Ja, also wird der Code in den geschweiften Klammern ausgeführt und der Wert von a wird gedruckt. Schließlich wird das Inkrement angewendet, was bedeutet, dass 1 zu a hinzugefügt wird.

Der Test wird dann wiederholt. Wenn true, wird der Schleifencode erneut ausgeführt und das Inkrement erneut angewendet. Dies wird immer wieder wiederholt, bis der Test falsch ist. An diesem Punkt wird die Ausführung nach dem Schließen der geschweiften Klammer fortgesetzt.

$ ./myprog
a ist gleich mit 0
a ist gleich mit 1
a ist gleich mit 2
a ist gleich mit 3
a ist gleich mit 4
a ist gleich mit 5 und ich bin fertig
$

Oben: Die Ausgabe, wenn die for-Schleife ausgeführt wird, ist identisch mit der der while-Schleife im vorherigen Kapitel - beide machen genau dasselbe.

In Bezug auf das, was sie tun, sind for-Schleifen und while-Schleifen ziemlich identisch. Beide schließen einen Codeabschnitt, den Sie mehrmals ausführen möchten, in eine Logik ein, welche steuert, wie oft er ausgeführt wird. Sie können verwenden, was am sinnvollsten ist oder was für Sie am saubersten aussieht!

Eine Sache, die Sie ziemlich oft tun möchten, ist, eine Variable gegen mehrere Werte zu testen und basierend auf jedem von ihnen verschiedene Dinge zu tun. Sie können dies mit einer Reihe verschachtelter if-Anweisungen tun:

#include <stdio.h>
 
void main (void)
{
  int a = 0;
  if (a == 0)
  {
    printf ("a ist gleich mit 0\n");
  }
  else if (a == 1)
  {
    printf ("a ist gleich mit 1\n");
  }
  else
  {
    printf ("a ist grösser als 1\n");
  }
}

Das wird allerdings ziemlich langwierig, daher bietet C eine bessere Möglichkeit, dies zu tun. Diese wird als switch-Anweisung bezeichnet.

#include <stdio.h>
 
void main (void)
{
  int a = 0;
 
  switch (a)
  {
    case 0 : printf ("a ist gleich mit 0\n");
      break;
    case 1 : printf ("a a ist gleich mit 1\n");
      break;
    default : printf ("a ist grösser als 1\n");
  }
}

Oben: Vergessen Sie nicht die break-Anweisungen am Ende jedes Falls in Ihren switch-Anweisungen!

Dies entspricht genau dem obigen Beispiel mit mehreren if-Anweisungen, ist jedoch viel kürzer. Wie funktioniert es?

Die erste Zeile besteht aus dem Schlüsselwortschalter mit dem Namen einer Variablen in runden Klammern. Dies ist die Variable, die anhand der verschiedenen Fälle getestet wird.

Der Hauptteil der switch-Anweisung besteht aus einer Reihe von case-Anweisungen. Die Variable a wird nacheinander mit jedem Fall verglichen. Wenn es mit dem Wert unmittelbar nach dem Wortfall übereinstimmt, werden die Codezeilen nach dem Doppelpunkt ausgeführt.

Der letzte Fall wird nur als default (Standard) bezeichnet. Jede switch-Anweisung sollte einen default-Fall als letztes in der Liste enthalten. Dies ist der Code, der ausgeführt wird, wenn keiner der anderen Fälle übereinstimmt.

Beachten Sie, dass die letzte Zeile in jedem Abschnitt das Wort break ist - dies ist sehr wichtig. Das Schlüsselwort break teilt dem Compiler mit, dass Sie an dieser Stelle aus der switch-Anweisung „ausbrechen“ möchten. Das heißt, die Ausführung von Code innerhalb des Switches zu beenden und die Ausführung nach dem Schließen der geschweiften Klammer fortzusetzen. Wenn Sie vergessen, die break-Anweisungen einzuschließen, wird jeder Fall nach dem gewünschten ebenso ausgeführt wie der gewünschte. Probieren Sie es aus, indem Sie den obigen Code kompilieren und ausführen. Im Terminal wird Folgendes angezeigt:

a ist gleich mit 0

Entfernen Sie nun die beiden break-Anweisungen, damit switch wie folgt aussieht:

#include <stdio.h>
 
void main (void)
{
  int a = 0;
 
  switch (a)
  {
    case 0 : printf ("a ist gleich mit 0\n");
    case 1 : printf ("a a ist gleich mit 1\n");
    default : printf ("a ist grösser als 1\n");
  }
}

und führen Sie es erneut aus - Sie werden jetzt sehen:

a ist gleich mit 0
a ist gleich mit 1
a ist grösser als 1

Nicht das, was Sie erwartet haben! Dies ist ein weiterer häufiger Fehler im C-Code. Das Vergessen der break-Anweisungen in Ihrem Code kann zu sehr unerwartetem Verhalten führen. Dies kann aber auch nützlich sein; Programmierer strukturieren manchmal eine switch-Anweisung mit Code, den sie in mehreren verschiedenen Fällen ausführen möchten, und lassen die break-Anweisungen absichtlich weg.

Die break-Anweisung hat eine Verwendung mehr. Sie kann innhalb von while und for Schleifen verwendet werden, um aus ihnen herausbrechen. Schauen Sie sich dieses Beispiel an:

#include <stdio.h>
 
void main (void)
{
  int a = 0;
  while (1)
  {
    printf ("a is equal to %d\n", a);
    a++;
    if (a == 5)
    {
      break;
    }
  }
  printf ("a ist gleich mit %d und ich bin fertig", a);
}

Wir haben also eine while-Schleife, in der der Test nur der Wert 1 ist. Dies ist ein Wert ungleich Null und gilt daher immer. Wenn Sie nach einer while (1) -Anweisung Code in eine geschweifte Klammern setzen, wird die Schleife niemals beendet. Sie wird für immer weiterlaufen. In diesem Fall haben wir jedoch eine alternative Möglichkeit bereitgestellt, um die Schleife zu beenden. Wir testen den Wert von a innerhalb der Schleife selbst in einer if-Anweisung, und wenn a gleich 5 ist, rufen wir break auf. Dadurch wird die Schleife beendet und die Ausführung mit der Anweisung nach der Schleife fortgesetzt. Eine solche break-Anweisung kann nützlich sein, um beispielsweise im Fehlerfall frühzeitig eine Schleife zu verlassen.

Das ist ungefähr alles, was Sie über den Kontrollfluss in C wissen müssen. Im nächsten Kapitel werden wir uns mit Zeigern befassen, die eine der nützlichsten und leistungsstärksten Funktionen von C sind.