Schalteranweisung in C: Ein Leitfaden für Anfänger

Hallo da draußen, zukünftige Programmierer! Heute tauchen wir in eine der nützlichsten Kontrollstrukturen im C-Programmieren ein: die Schalteranweisung (switch statement). Machen Sie sich keine Sorgen, wenn Sie neu hier sind; ich werde Sie Schritt für Schritt führen, genau wie ich es in den letzten Jahren mit unzähligen Schülern gemacht habe. Holen Sie sich ein Getränk Ihrer Wahl und lassen Sie uns gemeinsam diese Coding-Abenteuer beginnen!

Was ist eine Schalter-Case-Anweisung?

Stellen Sie sich vor, Sie sind in einem Eiscreme-Café und müssen einen Geschmack auswählen. Sie haben Vanille, Schokolade, Erdbeere und Minze. Jede Wahl führt zu einem anderen Eis in Ihrer Waffel. Genau so funktioniert eine Schalteranweisung im Programmieren!

Eine Schalteranweisung ist eine Kontrollflußanweisung, die es Ihnen ermöglicht, verschiedene Codeblöcke basierend auf dem Wert einer Variablen oder eines Ausdrucks auszuführen. Es ist wie eine elegantere und effizientere Version mehrerer if-else-Anweisungen.

Syntax der Schalter-Case-Anweisung

Schauen wir uns die grundlegende Struktur einer Schalteranweisung an:

switch (expression) {
case constant1:
// Code, der ausgeführt wird, wenn Ausdruck constant1 entspricht
break;
case constant2:
// Code, der ausgeführt wird, wenn Ausdruck constant2 entspricht
break;
...
default:
// Code, der ausgeführt wird, wenn Ausdruck keine Konstanten entspricht
}

Machen Sie sich keine Sorgen, wenn dies initially etwas einschüchternd aussieht. Wir werden es Stück für Stück auseinandernehmen.

Schlüsselkomponenten:

1. switch: Dieses Schlüsselwort initiiert die Schalteranweisung.
2. expression: Dies ist der Wert, der bewertet wird.
3. case: Jeder Fall stellt einen möglichen Wert des Ausdrucks dar.
4. break: Dieses Schlüsselwort beendet jeden Fallblock.
5. default: Dies ist ein optionaler Block, der ausgeführt wird, wenn keine Fälle übereinstimmen.

Wie die Schalter-Case-Anweisung funktioniert

Nun schauen wir uns an, wie dies in der Praxis funktioniert. Stellen wir uns ein einfaches Programm vor, das eine Nachricht basierend auf der Note eines Schülers ausgibt:

#include <stdio.h>

int main() {
char grade = 'B';

switch(grade) {
case 'A':
printf("Hervorragend!");
break;
case 'B':
printf("Gut gemacht!");
break;
case 'C':
printf("Gute Arbeit!");
break;
case 'D':
printf("Du hast bestanden.");
break;
case 'F':
printf("Bessere Glück im nächsten Mal.");
break;
default:
printf("Ungültige Note");
}

return 0;
}

In diesem Beispiel:

1. Haben wir eine Variable grade, die auf 'B' gesetzt ist.
2. Die Schalteranweisung bewertet grade.
3. Sie überprüft jeden Fall, bis sie einen Treffer findet ('B' in diesem Fall).
4. Wenn sie einen Treffer findet, führt sie den Code in diesem Fall aus ("Gut gemacht!").
5. Das break-Schlüsselwort beendet dann den Schalterblock.

Wenn grade keinen Fall getroffen hätte, würde der default-Block ausgeführt werden.

Flussdiagramm der Schalter-Case-Anweisung

Um zu visualisieren, wie eine Schalteranweisung funktioniert, schauen wir uns ein Flussdiagramm an:

+-------------+
|   Start     |
+-------------+
|
v
+-------------------+
| Evaluate expression|
+-------------------+
|
v
+----------------------+
| Compare with case 1  |
+----------------------+
|
v
+-------------+
|    Match?   |
+-------------+
Yes |     | No
|     |
v     v
+-----------------+    +----------------------+
| Execute case 1  |    | Compare with case 2  |
+-----------------+    +----------------------+
|                     |
v                     v
+-----------+         +-------------+
|   Break   |         |    Match?   |
+-----------+         +-------------+
|               Yes |     | No
|                   |     |
|                   v     v
|         +-----------------+    +------------+
|         | Execute case 2  |    |   ...      |
|         +-----------------+    +------------+
|                   |
|                   v
|            +-----------+
|            |   Break   |
|            +-----------+
|                   |
v                   v
+-----------+        +-----------+
|    End    | <------| Default   |
+-----------+        +-----------+

Dieses Flussdiagramm zeigt, wie die Schalteranweisung jeden Fall überprüft und den entsprechenden Codeblock ausführt.

Regeln für die Verwendung der Schalter-Case-Anweisung

Um Schalteranweisungen effektiv zu verwenden, beachten Sie folgende Regeln:

Regel	Beschreibung
Ausdruckstyp	Der Schalterausdruck muss einen ganzzahligen Typ (int, char, etc.) oder einen aufgezählten Typ haben.
Fallkonstanten	Fallbeschriftungen müssen Konstanten oder Literalwerte sein, keine Variablen.
Einzigartige Fälle	Jeder Fallwert muss innerhalb einer Schalteranweisung einzigartig sein.
break-Anweisung	Verwenden Sie break, um den Schalterblock nach Ausführung eines Falls zu beenden.
default-Fall	Der default-Fall ist optional und kann überall im Schalterblock erscheinen.

Weitere Schalter-Case-Anweisungsbeispiele

Schauen wir uns einige weitere Beispiele an, um unser Verständnis zu festigen.

Beispiel 1: Wochentage

#include <stdio.h>

int main() {
int day = 4;

switch(day) {
case 1:
printf("Montag");
break;
case 2:
printf("Dienstag");
break;
case 3:
printf("Mittwoch");
break;
case 4:
printf("Donnerstag");
break;
case 5:
printf("Freitag");
break;
case 6:
printf("Samstag");
break;
case 7:
printf("Sonntag");
break;
default:
printf("Ungültige Tagesnummer");
}

return 0;
}

Dieses Programm wird "Donnerstag" ausgeben, weil day auf 4 gesetzt ist.

Beispiel 2: Taschenrechner

#include <stdio.h>

int main() {
char operator;
double n1, n2;

printf("Geben Sie einen Operator (+, -, *, /) ein: ");
scanf("%c", &operator);
printf("Geben Sie zwei Operanden ein: ");
scanf("%lf %lf",&n1, &n2);

switch(operator)
{
case '+':
printf("%.1lf + %.1lf = %.1lf", n1, n2, n1+n2);
break;
case '-':
printf("%.1lf - %.1lf = %.1lf", n1, n2, n1-n2);
break;
case '*':
printf("%.1lf * %.1lf = %.1lf", n1, n2, n1*n2);
break;
case '/':
printf("%.1lf / %.1lf = %.1lf", n1, n2, n1/n2);
break;
default:
printf("Fehler! Der Operator ist nicht korrekt");
}

return 0;
}

Dieses Programm erstellt einen einfachen Taschenrechner mit einer Schalteranweisung.

Schalteranweisung durch Kombination mehrerer Fälle

Manchmal möchten Sie, dass mehrere Fälle denselben Code ausführen. Dies können Sie erreichen, indem Sie Fälle nebeneinander listen:

#include <stdio.h>

int main() {
char grade = 'B';

switch(grade) {
case 'A':
case 'B':
case 'C':
printf("Du hast bestanden!");
break;
case 'D':
case 'F':
printf("Du musst dich verbessern.");
break;
default:
printf("Ungültige Note");
}

return 0;
}

In diesem Beispiel führen Noten A, B und C zu "Du hast bestanden!", während D und F zu "Du musst dich verbessern." führen.

Und das war's! Sie haben gerade die Schalteranweisung in C gelernt. Denken Sie daran, dass Übung den Meister macht. Versuchen Sie, eigene Schalteranweisungen zu schreiben und verschiedene Szenarien auszuprobieren. Vor Ihnen liegt noch viel zu lernen, aber Sie werden bald wie ein Profi schalten!

Happy Coding und möge Ihre Schalter immer den richtigen Fall finden!

Credits: Image by storyset