Entscheidung/Auswahl

Hinsichtlich der Kontrollstruktur Entscheidung bzw. Auswahl gibt es prinzipiell drei Varianten:

Eine Entscheidung oder auch Auswahl, ist eine Struktur, die den Programmablauf insoweit verändert, dass aufgrund einer Bedingung bestimmte Befehle zusätzlich ausgeführt weren können.

Eine Bedingung kann man sich eigentlich immer als eine Frage formuliert vorstellen, die man nur mit ja oder nein beantworten kann.

Eine Bedingung ist also ein boolscher Ausdruck, der den Wahrheitwert true oder false (wahr oder falsch) ergibt. Bedingungen werden mittels sogenannter Vergleichsoperatoren formuliert.

AusdruckAusdruck in C#Vergleichsoperator
Ist a größer als b?a > b>
Ist a kleiner als b?a < b<
Ist a größer oder gleich b?a >= b>=
Ist a kleiner oder gleich b?a <= b<=
Ist a gleich b?a == b==
Ist a ungleich b?a != b!=

Einseitige Entscheidung mittels „if“

Das Befehlswort, das solch eine Entscheidungsstruktur einleitet, ist if. Dahinter folgt in einem runden Klammernpaar die auszuwertende Bedingung (eine Frage, auf die man nur mit Ja oder Nein antworten kann). Prinzipiell ist eine solche Entscheidung folgendermaßen aufgebaut:

if (Bedingung)
{
    // Auszuführende Anweisungen, wenn die Bedingung wahr ist
}
Struktogramm zu „Einseitige Entscheidung“

Das nachfolgende Beispielprogramm zeigt eine solche Entscheidungsstruktur:

Console.Write("Geben Sie das Passwort ein > ");
string password = Console.ReadLine();
            
// Passwort überprüfen
if (password == "strenggeheim")
{
    Console.WriteLine("Passwort akzeptiert");
}

Es wird eine Zeichenkette von der Tastatur eingelesen und in einer Variablen mit dem Bezeichner passwort gespeichert (Zeile 2).

Anschließend wird der Wert dieser Variablen mit der Zeichenkette „strenggeheim“ auf Identität überprüft (Zeile 5). Wenn dies der Fall ist, wird die Anweisung in Zeile 7 ausgeführt. Ist dies nicht der Fall, wird das Programm hinter den Anweisungsblock fortgesetzt.

Der Anweisungsblock wird durch das geschweifte Klammernpaar (Zeile 6 und 8) gebildet. Innerhalb dieses Anweisungsblocks können nun ein oder mehrere Anweisungen enthalten sein, die ausgeführt werden, wenn die zuvor formulierte Bedingung den Wahrheitswert true hat, also die eingelesene Zeichenlette identisch mit der fest vorgegebenen Zeichenkette „strenggeheim“ ist.

Zweiseitige Entscheidung mittels „if…else“

Für eine solche Entscheidungsstruktur kann auch ein Anweisungsblock angegeben werden, der Anweisungen enthält, die auszuführen sind, wenn die Bedingung den Wahrheitswert false hat, also nicht erfüllt ist.

if (Bedingung)
{
    // Anweisungen, die bei erfüllter Bedingung ausgeführt werden
}
else
{
    // Anweisungen, die bei nicht erfüllter Bedingung ausgeführt werden
}
Struktogramm zu „Zweiseitige Entscheidung

Hierzu ein Beispiel:

Console.Write("Geben Sie das Passwort ein > ");
string password = Console.ReadLine();
            
// Passwort überprüfen
if (password == "strenggeheim")
{
    Console.WriteLine("Passwort akzeptiert");
}
else
{
    Console.WriteLine("Passwort ist falsch!");
}

Hinter dem Befehlswort else befindet sich nun ein weiterer Anweisungsblock, der diejenigen Anweisungen enthält, die auszuführen sind, wenn die Bedingung den Wahrheitswert false besitzt.

Es können auch komplexere Entscheidungsstrukturen programmiert werden, die nacheinander mehrere Bedingungen abprüfen. Prinzipiell sieht das folgendermaßen aus:

if (BedingungEins)
{
    // AnweisungsblockEins
}
else if (BedingungZwei)
{
    // AnweisungsblockZwei
}
else if (BedingungDrei)
{
    // AnweisungsblockDrei
}
else
{
    // Anweisungen, die bei keiner der zuvor angegebenen Bedingungen
    // ausgeführt werden
}

Hier wird zuerst die BedingungEins überprüft. Hat diese den Wahrheitswert true, wird der nachfolgende AnweisungsblockEins ausgeführt und das Programm hinter der Entscheidungsstruktur (hinter der else-Anweisung) fortgeführt.
Andernfalls wird direkt BedingungZwei ausgewertet. Hat diese den Wahrheitswert true wird -analog zur BedingungEins– der zugehörige AnweisungsblockZwei ausgeführt und danach ebenfalls das Programm hinter der else-Anweisung fortgeführt.
Trifft BedingungZwei ebenfalls nicht zu, wird noch BedingungDrei geprüft und ggf. der AnweisungsblockDrei ausgeführt.
Trifft keine der zuvor definierten Bedingungen zu, wird der zu else gehörige Anweisungsblock ausgeführt.

Hierzu ebenfalls ein Beispiel:

Console.Write("Geben Sie Ihr Alter ein > ");
int alter = Convert.ToInt32(Console.ReadLine());

// Alter überprüfen
if (alter < 0)
{
    Console.WriteLine("Es gibt kein negatives Alter");
    Console.Beep();
}
else if (alter < 14)
{
    Console.WriteLine("Sie sind ein Kind");
}
else if (alter < 18)
{
    Console.WriteLine("Sie sind jugendlich");
}
else
{
    Console.WriteLine("Sie sind volljährig");
}

Zuerst wird geprüft, ob das eingegebene Alter kleiner Null, also eine negative Ganzzahl, ist. In diesem Fall wird eine entsprechende Meldung gefolgt von einem kurzen Piepton ausgegeben und das Programm hinter dem „else“-Anweisungsblock fortgesetzt.
Anschließend wird geprüft, ob der eingegebene Zahlenwert kleiner 14 ist. Sollte dies nicht der Fall sein, wird geprüft, ob der eingegebene Zahlenwert kleiner 18 ist. Da aufgrund der Reihenfolge der Bedingungen zuvor schon auf kleiner 14 geprüft wurde, muss die eingegebene Zahl mindestens 14 sein! Das gleiche gilt für die noch folgende Bedingung, bei der auf „kleiner 18“ geprüft wird. Ergaben alle drei Bedingungen aufgrund der Eingabe den Wahrheitswert false, wird nun der else-Anweisungsblock ausgeführt. Hatte eine der zuvor geprüften Bedingungen den Wahrheitswert true, wird der zugehörige Anweisungsblock ausgeführt und anschließend das Programm hinter dem else-Anweisungsblock fortgesetzt.

Noch ein Wort zu „Bedingung“

In allen bisherigen Beispielen war die Bedingung als ein einzelner Vergleich angegeben. Bedingungen können aber auch aus mehreren Vergleichsausdrücken bestehen. Die Wahrheitswerte mehrerer Vergleichausdrücke können dann noch mittels Logikoperatoren verknüpft werden. In C# gibt es folgende Logikoperatoren:

Logik-OperationBeispielLogikoperator
bedingtes logisches UND(a > 10) && (b < 0)&&
bedingtes logisches ODER(a > 10) || (b < 0)||
logisches EXKLUSIV-ODER(a > 10) ^ (b < 0)^
logisches NICHT!(a > 10)!

Die C# Sprachreferenz von Microsoft zu diesem Thema beschreibt dies detailliert. Dort wird auch prinzipiell zwischen zwei Arten von Logikoperatoren unterschieden. Das logische UND („&“) und das bedingte logische UND („&&“) sowie das logische ODER („|“) und das bedingte logische ODER („||“).
Empfehlenswert ist die Klammerung der zu verknüpfenden Ausdrücke, wenn mehrere Ausdrücke mit unterschiedlichen Logikoperatoren verbunden werden, da es eine Priorität gibt, ähnlich der „Punkt vor Strich“-Rechnung

Bedingtes logisches UND (&&), ein binärer Operator

Beim bedingten logischen UND müssen alle Teilausdrücke (hier: A bzw. B) den Wahrheitswert „true“ liefern, damit der Gesamtausdruck (hier: A && B) den Wahrheitswert „true“ hat.

ABA && B
falsefalsefalse
falsetruefalse
truefalsefalse
truetruetrue
Bedingtes logisches ODER (||), ein binärer Operator

Beim bedingten logischen ODER muss mindestens ein Teilausdruck (hier: A bzw. B) den Wahrheitswert „true“ liefern, damit der Gesamtausdruck (hier: A || B) den Wahrheitswert „true“ hat.

ABA || B
falsefalsefalse
falsetruetrue
truefalsetrue
truetruetrue
Logisches EXKLUSIV-ODER (^), ein binärer Operator

Beim logischen EXKLUSIV-ODER darf nur genau ein Teilausdruck (hier: A bzw. B) den Wahrheitswert „true“ liefern, damit der Gesamtausdruck (hier: A ^ B) den Wahrheitswert „true“ hat.

ABA ^ B
falsefalsefalse
falsetruetrue
truefalsetrue
truetruefalse
Logisches NICHT (!), ein unärer Operator

Beim logischen NICHT wird der Wahrheitswert eines Ausdrucks (hier: A) „negiert“ zu NICHT A (hier: !A), das heißt aus „false“ wird „true“ und aus „true“ wird „false“.

A!A
falsetrue
truefalse

Fallauswahl mittels „switch“

Eine weitere Variante der Entscheidung ist die sogenannte „Fallauswahl“. Diese unterscheidet sich aber insofern grundlegend von Entscheidungen des Typs if bzw. if…else.
Bei der Fallauswahl mittels switch wird eine Variable auf bestimmte Werte hin geprüft. Verwendet werden üblicherweise Variablen deren Datentyp Ganzzahltypen wie int oder char sind. In C# können bei der switch-Struktur keine Vergleichsoperatoren verwendet werden! Der prinzipielle Aufbau dieser Fallauswahl sieht folgendermaßen aus:

switch (variable)
{
    case Fall1:
        //Anweisungen für den Fall1
        break;
    case Fall2:
        //Anweisungen für den Fall2
        break;
    case Fall3:
        //Anweisungen für den Fall3
        break;
    default:
        //Anweisungen für den sonstigen Fall
        break;
}
Struktogramm für Fallauswahl

Und dazu gleich ein Beispiel:

Console.Write("Geben Sie eine der vier Himmelsrichtungen ein (N/O/S/W) > ");
char himmelsrichtung = Convert.ToChar(Console.ReadLine());

switch (himmelsrichtung )
{
    case 'N':
        // Anweisungen für die Himmelsrichtung Norden
        Console.WriteLine("Wir fahren nach Norden");
        break;
    case 'O':
        // Anweisungen für die Himmelsrichtung Osten
        Console.WriteLine("Wir fahren nach Osten");
        break;
    case 'S':
        // Anweisungen für die Himmelsrichtung Süden
        Console.WriteLine("Wir fahren nach Süden");
        break;
    case 'W':
        // Anweisungen für die Himmelsrichtung Westen
        Console.WriteLine("Wir fahren nach Westen");
        break;
    default:
        //Anweisungen für den Standardfall
        Console.WriteLine("Wir fahren in keine der vier Himmelsrichtungen");
        break;
}

Der Benutzer soll eine der vier Himmelsrichtungen mittels der Zeichen ‚N‘, ‚O‘, ‚S‘ oder ‚W‘ eingeben. Die Eingabe wird als Character (ein Zeichen) in der Variable mit dem Bezeichner himmelsrichtung gespeichert.

Anschließend wird der Wert dieser Variable auf die vier gewünschten Fälle hin untersucht. Alle anderen Fälle werden dann von dem Standardfall abgedeckt. Der Standardfall ist optional! Es müssen also konkret erwartete Werte für diese zu untersuchende Variable angegeben werden.
Die letzte Anweisung für jeden dieser definierten Fälle ist das Befehlswort break. Diese Anweisung bewirkt, dass die Programmausführung hinter dem Anweisungsblock der switch-Struktur fortgesetzt wird. Ohne die break-Anweisung würden ansonsten die Befehle in den nachfolgenden definierten Fällen ausgeführt werden.
Daher kann auch für mehrere Fälle die selbe Anweisungsfolge ausgeführt werden. Hierzu ein Beispiel:

Console.WriteLine("Menü");
Console.WriteLine("A: Bearbeite Spielerdaten");
Console.WriteLine("B: Starte Spiel");
Console.WriteLine("C: Programmende");
char auswahl = Convert.ToChar(Console.ReadLine());

switch (auswahl)
{
    case 'A':
    case 'a':
        // Anweisungen für Bearbeitung der Spielerdaten
        break;
    case 'B':
    case 'b':
        // Anweisungen für Start des Spiels
        break;
    case 'C':
    case 'c':
        // Anweisungen für Programmende
        break;
    default:
        Console.WriteLine("Falsche Auswahl");
        break;
}

Hier sind nun jeweils zwei Fälle für den Wert der Variablen auswahl angegeben. Wenn der Benutzer einen Menüpunkt wählt, kann er dies durch die Eingabe des Klein- oder Großbuchstabens machen. Natürlich gilt das auch noch für mehr als zwei Werte und die Werte können bei Verwendung einer Ganzzahlvariablen ebenfalls mehrere Ganzzahlwerte sein.

Mein Arbeitsblatt zu diesem Thema:

07 EntscheidungenHerunterladen

Zurück zu Sequenz

Weiter zu Wiederholung

Nach oben zu Strukturierte Programmierung