Bedingte Anweisung und Verzweigung

Eine bedingte Anweisung ist eine Kontrollstruktur in der Programmierung. Ein Programmabschnitt wird dabei nur unter einer bestimmten Bedingung ausgeführt.

Eine Verzweigung legt fest, welcher von zwei oder mehreren Programmabschnitten, abhängig von einer oder mehreren Bedingungen, ausgeführt wird.

Eine bedingte Anweisung besteht aus einer Bedingung und einem Codeabschnitt, der wiederum aus einer oder mehreren Anweisungen besteht. Wird beim Programmablauf die bedingte Anweisung erreicht, dann wird erst die Bedingung ausgewertet, und falls diese zutrifft (und nur dann), wird anschließend der Codeabschnitt ausgeführt. Danach wird die Programmausführung mit den auf die bedingte Anweisung folgenden Anweisungen fortgesetzt.

In Pseudocode formuliert hat eine bedingte Anweisung folgende Form:

falls Bedingung dann
  Anweisung(en)
ende

Die Bedingung ist ein Ausdruck, der nach den dafür geltenden Regeln der Programmiersprache (Semantik und Vorrangfolge der Operatoren) ausgewertet wird. Er muss als Resultat einen Wahrheitswert (wahr: Bedingung trifft zu, oder falsch: Bedingung trifft nicht zu) liefern, oder sein Resultat muss nach den Umwandlungsregeln der Sprache implizit in einen Wahrheitswert umwandelbar sein.

Die Bedingung ist nicht generell gültig, sondern zeitabhängig. Sie wird jedes Mal ausgewertet, wenn die bedingte Anweisung beim Programmablauf erreicht wird, und es kommt darauf an, ob sie zu dem jeweiligen Zeitpunkt zutrifft oder nicht. Das kann sich von mal zu mal ändern, wenn die bedingte Anweisung mehrmals erreicht wird.

Beispiele: In vielen Programmiersprachen mit C-ähnlicher Syntax, z. B. C++, C# und Java, werden bedingte Anweisungen folgendermaßen formuliert:

if (Temperatur < 20)
    Heizung_Einschalten();

Ist der hier abgefragte Wert Temperatur kleiner als 20, wird die Funktion Heizung_Einschalten() ausgeführt. Ist die Bedingung nicht erfüllt, also Temperatur nicht kleiner als 20, wird die Anweisung übersprungen.

In der Datenbanksprache SQL gibt es etwa folgendes Konstrukt:

DELETE FROM tabelle WHERE tabelle.id = 42;

Dies entspricht einer Schleife, die über die Einträge in einer Tabelle geht und in der für jeden Tabelleneintrag eine bedingte Anweisung ausgeführt wird: Alle Einträge, für die die Bedingung „id = 42“ zutrifft, werden gelöscht; alle übrigen Einträge bleiben dabei unberührt.

Eine Verzweigung, auch Auswahl oder Selektion genannt, besteht aus einer Bedingung und zwei Codeabschnitten. Wieder wird erst die Bedingung ausgewertet, und falls sie zutrifft, wird anschließend der erste Codeabschnitt ausgeführt, anderenfalls wird der zweite Codeabschnitt ausgeführt:

falls Bedingung dann
  Anweisung(en)
sonst
  Anweisung(en)
ende

Beispiel in der Programmiersprache C:

if (Temperatur < 20)
    Heizung_Einschalten();
else
    Heizung_Ausschalten();

In manchen Programmiersprachen gibt es den ternären Auswahloperator, der auch bedingter Ausdruck genannt wird. Dieser Operator kann zum Beispiel für Wertzuweisungen an Variablen verwendet werden, aber auch Bestandteil von komplexeren Ausdrücken sein. Er verarbeitet drei Parameter in der Form wenn Bedingung dann Ausdruck1 sonst Ausdruck2. Zuerst wird Bedingung ausgewertet. Ist das Ergebnis wahr, wird Ausdruck1 ausgewertet, anderenfalls Ausdruck2. Das dabei entstehende Ergebnis ist auch das Ergebnis des Auswahloperators. Folgender Code in der Programmiersprache C zeigt zweimal die gleiche Aktion – einmal als if-else-Konstrukt und einmal mit dem Auswahloperator:

// Variante mit if-else-Anweisung
const char* str1;
if (zahl==5)
    str1 = "Zahl gleich 5";
else
    str1 = "Zahl ungleich 5";

// Variante mit Auswahloperator
const char* str2 = zahl==5 ? "Zahl gleich 5" : "Zahl ungleich 5";


// Initialisierung einer immutablen Variable mit Auswahloperator (mit if-else nicht möglich)
const char* const str3 = zahl==5 ? "Zahl gleich 5" : "Zahl ungleich 5";

In vielen Sprachen wird der Operator mit den Worten if-then-else formuliert, z. B. in F#:

let x = if zahl < 5 then 0 else 1

In vielen Programmiersprachen gibt es auch mehrfache Verzweigungen, auch Fallunterscheidungen genannt. Dabei sind zwei Formen zu unterscheiden: Entweder bestimmt das Ergebnis eines Ausdrucks, welcher von mehreren Codeabschnitten ausgeführt wird und ob überhaupt einer davon ausgeführt wird, oder es gibt mehrere Bedingungen, denen jeweils ein Codeabschnitt zugeordnet ist. In beiden Formen kann ein else-Teil vorhanden sein.

Der Ausdruck wird ausgewertet und mit den Wertangaben (hier Wert1 bis Wert3) verglichen. Bei Übereinstimmung werden die Anweisungen nach der Wertangabe ausgeführt. Wenn kein Wert übereinstimmt, werden die Anweisungen nach sonst ausgeführt, falls der else-Teil vorhanden ist:

falls Ausdruck gleich
  Wert1: Anweisung(en)
  Wert2: Anweisung(en)
  Wert3: Anweisung(en)
  sonst: Anweisung(en)
ende

Beispiel in der Programmiersprache C:

switch (zahl)
{
case 0:
    v = 1;
    break;  // 'break' ist hier nötig, damit nicht auch die ...
case 1:
    v = 2;
    break;  // ... folgenden Anweisungen ausgeführt werden (Besonderheit in C)
case 2:
    v = 5;
    break;
default:
    v = 10; // der sonst-Teil
}

Das folgende Beispiel in der Programmiersprache C# prüft, in welcher (meteorologischen) Jahreszeit ein Datum liegt, und gibt eine Textzeile aus:

int month = date.Month;
string season;
switch (month)
{
case 3: case 4:	case 5:
	season = "spring";
	break;
case 6:	case 7:	case 8:
	season = "summer";
	break;
case 9:	case 10: case 11:
	season = "autumn";
	break;
case 12: case 1: case 2:
	season = "winter";
	break;
default:
	season = "invalid date";
	break;
}
Console.WriteLine("The date is in " + season + ".");

Die genaue Semantik eines solchen Konstrukts hängt stark von der jeweiligen Programmiersprache ab. So ist z. B. der else-Teil nicht immer erlaubt, manchmal muss er aber vorhanden sein. Manchmal schreibt die Sprachdefinition auch vor, dass es zu einem Laufzeitfehler kommt, falls der else-Teil fehlt und der Ausdruck keinen der angegebenen Werte annimmt.

Die Bedingungen werden der Reihe nach ausgewertet, solange, bis eine davon zutrifft. Dann wird der zu dieser Bedingung gehörende Codeabschnitt ausgeführt, und die Behandlung der mehrfachen Verzweigung ist damit beendet. Wenn keine der Bedingungen zutrifft, wird der else-Teil ausgeführt, falls er vorhanden ist:

falls Bedingung dann
  Anweisung(en)
sonst falls Bedingung2 dann
  Anweisung(en)
sonst
  Anweisung(en)
ende

In technischer Hinsicht ist das in den meisten Sprachen kein eigenständiges Konstrukt, sondern wird als Verkettung von Verzweigungen realisiert, indem jede Verzweigung, außer der ersten, den Else-Teil der vorhergehenden Verzweigung darstellt.

Die folgende Methode in der Programmiersprache C# prüft, ob ein Zeitpunkt vor, nach oder in einem gegebenen Zeitraum liegt und gibt eine Textzeile aus:

void Compare(DateTime time, DateTime startTime, DateTime endTime)
{
	if (time < startTime)
		Console.WriteLine("The point in time is before the period.");
	else // time >= startTime
	{
		if (time > endTime)
			Console.WriteLine("The point in time is after the period.");
		else // time >= startTime && time <= endTime
			Console.WriteLine("The point in time is in the period.");
	}
}

• Befehlssatz
• Kontrollfluss
• Yoda Conditions