D-Programmierung: Kontrollstrukturen

Kontrollstrukturen in D

Bis jetzt konnten Sie nur Programme schreiben, die immer dasselbe gemacht haben, es gab nur einen Weg. Um flexibler zu sein, benötigt man Kontrollstrukturen.

Bedingungen

If-Verzweigung

Die einfachste und vielleicht auch mächtigste Methode ist die if-Verzweigung.

import std.stdio;

void main()
{
  int zahl = (13 + 5);
  if(zahl > 0)
  {
      writefln("Das Ergebnis ist größer als 0");
  }
  if(zahl <= 0)
  {
     writefln("Das Ergebnis ist kleiner oder gleich 0");
  }
}

Sie werden mir zustimmen, dass das irgendwie umständlich ist, hier zweimal if zu verwenden, daher gibt es "else".

import std.stdio;

void main()
{
  int zahl = (13 + 5);
  if(zahl > 0)
  {
      writefln("Das Ergebnisist größer als 0");
  }
  else
  {
     writefln("Das Ergebnis ist kleiner oder gleich 0");
  }
}

Der Unterschied ist hier gering, aber wenn man komplizierte Bedingungen hat, dann wird es praktisch.

"if" verwendet man also so:

if(Bedingung)
   Anweisung1
else
   Anweisung2

else ist optional, das heißt, dass man if auch alleine verwenden kann, so wie ich es im ersten Beispiel getan habe. Die geschweiften Klammern, die ich im Beispiel verwendet habe, kann man weglassen, wenn man nur eine Anweisung nach dem if (oder else) ausführen will. Es empfiehlt sich aber, die Klammern immer zu verwenden; das erleichtert die Übersicht und spätere Änderungen.

Bedingter Ausdruck

Eine extrem kurze Variante, die der if-Verzweigung sehr ähnlich ist, ist der bedingte Ausdruck.

Bedingung ? Anweisung1 : Anweisung 2

Beispiel

...
(zahl > 0)? writef("größer 0") : writef("kleiner/geleich 0");
...

Dies eignet sich nicht für komplizierte Verzweigungen, aber bei einfachen Dingen ist dies eine sinnvolle und kurze Alternative.

Switch

Wenn Sie jedoch eine Menge an Möglichkeiten haben, die alle abgefragt werden müssen, z.B. einen Roboter, der Befehle erkennen soll, ist es zwar möglich, mit if und else zu arbeiten:

if(command == stop)
   stop();
else if(command == move)
        move();
     else
        ...
     else
       writef("Unbekannter Befehl");

Jedoch ist das sehr umständlich. Die beste Methode dafür ist switch:

switch(command)
{
   case stop: stop();
          break;
   case move: move();
          break;
   default: writef("Unbekannter Befehl");
}

Das ist doch schon sehr viel übersichtlicher.

Switch wird so verwendet:

switch(Variable)
{
   case Möglichkeit1: Anweisung1;
           break;
   case Möglichkeit2: Anweisung2;
           break;
   default: Anweisung die ausgeführt wird, wenn keine andere zutrifft.
}

Wichtig ist das "break;" zwischen den verschiedenen case-Anweisungen, denn switch kann noch mehr. Wenn man das break vergisst, dann wird ab der ersten zutreffenden Möglichkeit alles ausgeführt; das break ist ein Ausdruck der (nicht nur bei switch) die aktuelle Ebene verlässt. Diesem break werden wir noch häufiger begegnen.

default wird also ausgeführt, wenn keine andere Mäglichkeit zutrifft ODER wenn kein break gesetzt wurde.

Schleifen

for-Schleife

Die for-Schleife ist eine abweisende Schleife, da erst geprüft wird, ob die gestellte Bedingung wahr ist.

Die Syntax der for-Schleife lautet:

for(Ausdruck_1; Ausdruck_2; Ausdruck_3){
   Anweisung
}

Normalerweise wird die for-Schleife so verwendet, dass die Ausdrücke 1 und 3 Zuweisungen an die Laufvariable sind und der Ausdruck_2 die Bedingung über den Wert der Laufvariablen ist.

Hier ein Beispiel dazu:

import std.stdio;

int main()
{ 
  int i; // Dies ist unsere Laufvariable
  for(i = 0; i < 10; i = i+1){
      writef("%d",i);
      if(i < 9){
         writef(",");
      }
  }
  return 0;
}

Die Ausgabe in der Konsole lautet:

0,1,2,3,4,5,6,7,8,9

Die Schleife ist nun 10 Mal durchgelaufen (von 0 bis 9). Als die Laufvariable i den Wert 9 hatte, wurde die Bedingung i < 10; erfüllt, und das Programm bricht die Schleife automatisch ab.

while-Schleife

Die while-Schleife ist wie die for_Schleife eine abweisende Schleife.

Der Syntax der while-Schleife lautet:

while (Ausdruck)
   Anweisung

Der Unterschied zur for-Schleife besteht darin, dass sie eine Anweisung in Abhängigkeit von der Bewertung eines Ausdrucks wiederholt ausgeführt wird. Da der Ausdruck vor der Anweisung bewertet wird, spricht man von einer "abweisenden Schleife". Der Ausdruck wird zuerst berechnet, dann geprüft und, wenn die Bedingung wahr ist, ausgeführt. Ist die Anweisung von Anfang an falsch, so wird die Schleife übersprungen.

Die while-Schleife ist auch äquivalent zur for-Schleife, mit folgender Syntax:

Ausdruck_1;
while(Ausdruck_2){
   Anweisung
   Ausdruck_3;
}

Hierzu ein Beispiel:

import std.stdio;

int main()
{
   int i; // Dies ist unsere Laufvariable
      while(i < 10){
         writef("%d",i);
         if(i < 9){
            writef(",");
         }
         i++;
       }
   return 0;
}

Die Ausgabe in der Konsole lautet auch hier:

0,1,2,3,4,5,6,7,8,9