1. Syntax der Verzweigungen: if, else, else if
Wenn man gerade mit dem Programmieren anfängt, scheint ein Programm oft nur ein Taschenrechner zu sein: Zahlen eingeben, Ergebnis bekommen. Schnell merkt man aber, dass ein echtes Programm fast immer „verzweigt“: hat der Nutzer dies eingegeben — machen wir so, hat er jenes eingegeben — sonst anders. Selbst im C++-Standard wird der Begriff condition („Bedingung“) als wichtiger Bestandteil von Steuerungsstrukturen wie if hervorgehoben.
Der einfachste Gedanke für heute: if ist wie eine Kreuzung auf der Straße. Die Bedingung ist eine Frage, die das Programm mit true oder false beantwortet und dann einen der Zweige auswählt.
Bevor man „clevere“ Bedingungen zusammenbaut, ist es wichtig, im Kopf Ordnung zu schaffen: if ist keine Magie, sondern eine sehr strikte Konstruktion. In den Klammern nach if muss ein Ausdruck vom Typ bool stehen (oder etwas, das darauf konvertiert wird), und danach folgt ein Statement oder ein Block von Statements. Und hier beginnt die erste Auseinandersetzung von Anfängern mit der Syntax: wo sind runde Klammern, wo geschweifte, und warum zerstört ein überflüssiges Semikolon ; die Logik.
Basis-if: „wenn (…) dann …“
Das Mini-Skelett sieht so aus:
if (condition) {
// Aktionen, wenn condition == true
}if
Beispiel: „volljährig oder nicht“
Lassen Sie uns sehr direkt sein: Wir lesen das Alter ein und geben den Status aus.
#include <iostream>
int main() {
int age = 0;
std::cin >> age;
if (age >= 18) {
std::cout << "adult\n"; // zum Beispiel bei Eingabe 18 -> adult
}
}
Wichtig ist hier zu fühlen: age >= 18 — das ist ein Ausdruck, der zu true oder false ausgewertet wird. Wenn er true ist, wird der Block ausgeführt.
else: „ansonsten machen wir das“
Wenn if „wenn wahr“ ist, dann ist else „wenn nicht wahr“. Es bezieht sich immer auf das nächste if, das noch kein zugehöriges else hat (das ist ein wichtiger Punkt: Einrückungen und geschweifte {} retten einem wirklich den Nerv).
Basisform:
if (condition) {
// true-Zweig
} else {
// false-Zweig
}if / else
Und das ist bereits eine vollständige „links/rechts“-Gabelung.
Beispiel: „adult/minor“
#include <iostream>
int main() {
int age = 0;
std::cin >> age;
if (age >= 18) {
std::cout << "adult\n"; // 18 -> adult
} else {
std::cout << "minor\n"; // 17 -> minor
}
}
Achten Sie auf Lesbarkeit: die beiden Zweige sind fast wie zwei Absätze Text. Genau danach streben wir: Code soll mit den Augen lesbar sein, nicht wie ein Rätsel erraten werden.
else if: „ansonsten wenn … ansonsten wenn … ansonsten …“
Jetzt kommen wir zu der Situation, in der eine einzige Zweigwahl aus mehreren nötig ist. Das ist sehr häufig: eine Zahl kann positiv/negativ/null sein, ein Befehl kann "add"/"remove"/"exit" sein, eine Note kann „sehr gut/gut/zufriedenstellend/schlecht“ sein.
Eine Kette sieht so aus:
if (cond1) {
...
} else if (cond2) {
...
} else if (cond3) {
...
} else {
...
}
Regel des Tages: in so einer Kette wird genau ein Zweig ausgeführt — der erste passende von oben nach unten.
Beispiel: Vorzeichen einer Zahl
#include <iostream>
int main() {
int x = 0;
std::cin >> x;
if (x > 0) {
std::cout << "positive\n"; // 5 -> positive
} else if (x < 0) {
std::cout << "negative\n"; // -3 -> negative
} else {
std::cout << "zero\n"; // 0 -> zero
}
}
Warum ist die Reihenfolge wichtig? Weil die Prüfungen von oben nach unten laufen. Hätten wir aus Versehen zuerst x >= 0 geschrieben, wäre der else if (x < 0) nahezu nutzlos: alles, was nicht negativ ist, hätte bereits die erste Prüfung „gefressen“.
3. Lesbarkeit von Verzweigungen: {}, Bedeutungsebenen und Namen für Prüfungen
Es gibt zwei Kategorien von Anfängern: diejenigen, die geschweifte {} immer setzen, und diejenigen, die einmal aus Frust zwei Stunden wegen fehlender {} verloren haben — und danach ebenfalls immer setzen.
Formal erlaubt C++ so etwas:
if (condition)
std::cout << "Hello\n";
Aber für einen Anfänger ist das wie Fahrradfahren ohne Hände: manche können es, aber wir lernen gerade fahren, nicht Passanten beeindrucken.
Warum „eine Zeile ohne {}“ gefährlich ist
Das Problem tritt auf, wenn Sie zuerst eine einzige Zeile geschrieben haben und später eine zweite hinzufügen, aber die Klammern vergessen. Der Code kompiliert, macht aber „irgendwas Merkwürdiges“.
Vergleichen Sie:
// SCHLECHT: leicht zu zerstören beim Hinzufügen von Zeilen
if (age >= 18)
std::cout << "adult\n";
std::cout << "welcome!\n"; // wird IMMER ausgefuehrt
und
// GUT: Struktur ist immer offensichtlich
if (age >= 18) {
std::cout << "adult\n";
std::cout << "welcome!\n";
}
Die zweite Version sagt buchstaeblich visuell: „diese beiden Zeilen sind eine Aktion fuer den Zweig“.
else if und verschachteltes if: unterschiedliche Bedeutungen
Eine sehr verbreitete Verwirrung: „kann ich nicht einfach ein if in ein anderes if schachteln?“ Das geht. Aber die Bedeutung ist anders. Und wenn die Bedeutung anders ist — dann sollte man so schreiben, dass der Leser (auch Sie selbst in einer Woche) das sofort sieht.
else if ist die Auswahl einer einzigen Alternative aus einer Menge sich gegenseitig ausschließender Optionen.
Verschachteltes if bedeutet: wir haben bereits einen Zweig gewählt und präzisieren innerhalb dieses Zweigs.
Beispiel: wo ein verschachteltes if nötig ist
Angenommen: zuerst prüfen wir, ob das Alter überhaupt valide ist (nicht negativ), und dann entscheiden wir adult/minor.
#include <iostream>
int main() {
int age = 0;
std::cin >> age;
if (age < 0) {
std::cout << "invalid\n"; // -5 -> invalid
} else {
if (age >= 18) {
std::cout << "adult\n"; // 20 -> adult
} else {
std::cout << "minor\n"; // 7 -> minor
}
}
}
Die Bedeutung hier ist: „wenn das Alter invalid ist — sofort invalid; ansonsten entscheiden wir adult/Kind“.
Wenn man versucht, das in eine einzige else if-Kette zu quetschen, geht das zwar, ist aber für Anfänger meist schwerer zu lesen, weil verschiedene Bedeutungsebenen vermischt werden: Datenvalidierung und Datenklassifikation.
Machen Sie Bedingungen lesbar: benennen Sie Prüfungen
In dieser Vorlesung geht es nicht nur darum, „wie if funktioniert“, sondern auch darum, „wie Sie Ihren Code so schreiben, dass er nicht wie ein Chiffre aussieht“. Ein sehr einfaches Mittel ist, einen Teil der Prüfung in eine Variable vom Typ bool mit einem aussagekraeftigen Namen auszulagern.
Das sind keine „ueberfluessigen Variablen“, sondern Beschriftungen an den Leitungen. Ohne Beschriftung kann man zwar verbinden, aber die Reparatur danach tut weh.
#include <iostream>
int main() {
int age = 0;
std::cin >> age;
bool is_adult = (age >= 18);
if (is_adult) {
std::cout << "adult\n";
} else {
std::cout << "minor\n";
}
}
Der Vorteil dieses Ansatzes: die Bedingung if (is_adult) liest sich fast wie ein natuerlicher englischer Satz. Nachteil: man muss einen Namen finden. Aber das ist nur in den ersten Wochen eine „Hürde“, danach macht das Gehirn das automatisch.
4. Praktisches Mini‑Beispiel: „Befehls-Handler“ ohne Schleifen
Jetzt bauen wir eine kleine App-Vorlage, die im weiteren Kurs weiterentwickelt wird. Vorerst ohne Schleifen (die haben wir noch nicht behandelt), also verarbeitet das Programm genau einen Befehl und beendet sich. Selbst in dieser Form wirkt es bereits wie ein echtes Konsolen-Interface: der Nutzer gibt einen Befehl ein, das Programm waehlt, was zu tun ist.
Die Idee ist einfach: wir lesen eine Zeichenkette cmd und machen unterschiedliche Aktionen.
Version 1: drei Befehle
#include <iostream>
#include <string>
int main() {
std::string cmd;
std::cin >> cmd;
if (cmd == "hello") {
std::cout << "Hello!\n"; // hello -> Hello!
} else if (cmd == "help") {
std::cout << "Commands: hello, help, exit\n";
} else if (cmd == "exit") {
std::cout << "Bye!\n"; // exit -> Bye!
} else {
std::cout << "Unknown command\n"; // qwerty -> Unknown command
}
}
Beachten Sie, wie gut das lesbar ist: von oben nach unten wie eine Liste von Regeln. Das ist einer der Gruende, warum die else if-Kette in fruehen Lernphasen so beliebt ist.
Version 2: Befehl mit Zahl
Sagen wir, der Befehl ist "age", und danach gibt der Benutzer eine Zahl ein. Wir machen jetzt keine aufwendigen Eingabepruefungen (das kommt separat), zeigen aber, wie ein if-Zweig sein eigenes kleines Szenario enthalten kann.
#include <iostream>
#include <string>
int main() {
std::string cmd;
std::cin >> cmd;
if (cmd == "age") {
int age = 0;
std::cin >> age;
if (age >= 18) {
std::cout << "adult\n"; // age 20 -> adult
} else {
std::cout << "minor\n"; // age 7 -> minor
}
} else {
std::cout << "Try command: age\n";
}
}
Beachten Sie: innerhalb des Zweigs cmd == "age" führen wir eine weitere Verzweigung durch. Das ist normal und sehr praxisnah: „zuerst den Modus waehlen, dann innerhalb des Modus die Aktion bestimmen“.
Kleine Skizze: wie if / else if / else ausgeführt werden
Manchmal ist es hilfreich, else if nicht als „magische Worte“ zu sehen, sondern als einfachen Algorithmus: zuerst erste Bedingung pruefen — wenn ja, ausfuehren und fertig; wenn nein, weiter.
flowchart TD
A[Start] --> B{cond1?}
B -->|ja| C[Zweig 1]
B -->|nein| D{cond2?}
D -->|ja| E[Zweig 2]
D -->|nein| F{cond3?}
F -->|ja| G[Zweig 3]
F -->|nein| H[else-Zweig]
C --> Z[Ende]
E --> Z
G --> Z
H --> Z
Dieses Diagramm hilft zu verstehen, was der wichtigste Fakt des Tages ist: es wird nur ein Zweig ausgeführt, und die Pruefung erfolgt von oben nach unten.
5. Typische Fehler bei der Arbeit mit if/else
Fehler Nr. 1: Semikolon nach if.
Anfaenger schreiben manchmal if (cond); — das sieht fast richtig aus, aber die Bedeutung bricht vollstaendig zusammen. Ein Semikolon ist ein „leeres Statement“: die Bedingung wurde geprüft, aber dann wurde „nichts gemacht“. Der Block danach wird ganz normal als unabhängiger Block ausgeführt, also meist immer. Wenn Sie seltsames Verhalten sehen wie „Zweig wird immer ausgeführt“, suchen Sie zuerst nach einem ueberschuessigen ;.
Fehler Nr. 2: Zweige ohne {} und die „ausgerissene Zeile“.
Zuerst funktioniert alles: der Zweig hat eine Zeile. Dann fuegen Sie eine zweite Zeile hinzu und vergessen die geschweiften Klammern, und die zweite Zeile wird immer (oder nie) ausgefuehrt — je nachdem, wo sie landet. Das ist einer der schlimmsten Fehler: der Compiler meckert nicht, aber die Logik ist anders. Die Gewohnheit, {} immer zu setzen, heilt das fast zu 100 %.
Fehler Nr. 3: Sinn von else if und verschachteltem if vertauscht.
Wenn Sie „eine Option aus vielen“ waehlen wollen — verwenden Sie eine else if-Kette. Wenn Sie zuerst etwas prüfen und innerhalb dieses Zweigs noch weiter differenzieren wollen — verwenden Sie ein verschachteltes if. Werden diese Bedeutungen vermischt, wird der Code schwer lesbar: mag zwar laufen, aber es ist nicht klar, was der Autor ausdruecken wollte.
Fehler Nr. 4: schlechte Reihenfolge der Pruefungen in einer else if-Kette.
Das Problem entsteht, wenn die erste Pruefung zu „weit gefasst“ ist und Fälle abfängt, die eigentlich in die unteren Zweige gehoeren. Zum Beispiel if (x >= 0) vor else if (x == 0) — und der Zweig x == 0 wird niemals ausgefuehrt. Das laesst sich leicht beheben: zuerst spezifischere Faelle, dann allgemeinere (oder vorher die „Treppe“ von oben nach unten gedanklich durchgehen und dann erst den Code schreiben).
Fehler Nr. 5: lange Zweige und „Verlust der Bedeutung“.
Manchmal schreibt ein Anfänger in jeden Zweig ca. 40 Zeilen. Formal ist das ok, aber schwer zu lesen: man vergisst, welche Bedingung den Zweig gewaehlt hat, bevor man ans Ende gescrollt hat. In diesem Kurs besprechen wir noch keine Funktionen; die einfache Empfehlung lautet: halten Sie Zweige kurz, geben Sie aussagekraeftige Ausgaben und machen Sie Bedingungen so klar wie moeglich. Wenn Funktionen kommen, lernen wir, wie man main „verschlankt“, aber bis dahin ueben wir sauberen Stil direkt hier.
GO TO FULL VERSION