C++ Tutorial

if Verzweigung

Syntax

Die if-Verzweigung wird eingesetzt, wenn in Abhängigkeit von einer Bedingung verschiedene Anweisungen auszuführen sind. Sie hat folgende Syntax:

if ([INIT;] BEDINGUNG)
   ANWEISUNG1;     // if-Zweig
[else
   ANWEISUNG2;]    // else-Zweig

INIT ist ein optionaler Initialisierungsausdruck und BEDINGUNG ein beliebiger Ausdruck, der entweder ein ganzzahliges oder ein boolsches Ergebnis liefert. In der Regel ist BEDINGUNG ein Vergleichs- oder Logikausdruck.

Ergibt die Auswertung der Bedingung true (oder einen Wert ungleich 0), wird ANWEISUNG1 ausgeführt und ansonsten ANWEISUNG2.

1:	// Ausdruck mit logischem Vergleich
2:	if (var == 10)   // Falls var gleich 10
3:    var = 0;      // var auf 0 setzen
4:	else             // sonst
5:    var++;        // var inkrementieren
6:	
7:	//Ausdruck mit ganzzahligem Vergleich
8:	if (var)       // Falls var ungleich 0 (=true!)
9:     std::cout << "ungleich Null";
10:	else          // sonst
11:    std::cout << "gleich Null";

Nach der Klammer der if-Abfrage steht kein Semikolon. Wird hier ein Semikolon gesetzt, gilt dies als leere Anweisung, d.h. bei erfüllter Bedingung wird nichts ausgeführt!

Der else-Zweig ist optional. Ist er nicht vorhanden und die Auswertung des Ausdrucks ergibt false, wird mit der nächsten Anweisung nach dem if-Zweig fortgefahren. Im nachfolgenden Beispiel wird die Variable var nur dekrementiert, wenn deren Inhalt größer 0 ist.

1:	if (var > 0)
2:    var--;
3:	std::println("var: {}\n",var);

Sehen Sie sich einmal die folgenden if-Anweisungen an:

if (var == 10)
    ...
if (var = 10)
   ...

Beide Anweisungen sind syntaktisch korrekt! Im ersten Fall wird die Variable var mit dem Wert 10 verglichen. Im zweiten Fall wird der Variable var der Wert 10 zugewiesen und das Ergebnis der Zuweisung ausgewertet, welches immer true ist.

Auszuführende Anweisungen

Standardmäßig folgt auf ein if oder else nur eine Anweisung. Sollen mehrere Anweisungen ausgeführt werden, sind sie in einen Block {...} einzuschließen. Dabei sollte auf eine saubere Formatierung geachtet werden, damit das Programm übersichtlich bleibt.

1:	short var;
2:	// Datum einlesen
3:	// Im Fehlerfall Eingabestream zuruecksetzen
4:	if (std::cin >> var; std::cin.fail())
5:	{
6:    // Fehler löschen und restl. Eingabe verwerfen
7:    std::cin.clear();
8:    std::cin.ignore(std::numeric_limits<int>::max(),'\n');
9:	}
10:	else
11:    std::cout << std::format("Eingabe war {}\n",var);

Innerhalb eines if- oder else-Zweigs sind alle Anweisungen zulässig. So können in einem Zweig weitere if-Anweisungen folgen oder Variablen definiert werden. Diese Variablen sind dann nur innerhalb des Zweigs gültig.

Mehrere Bedingungen

Eine if-Anweisung kann mehrere Bedingungen enthalten, die mit logischen Operatoren verknüpft werden.

1:	// Hier müssen beide Bedingungen erfüllt sein
2:	if ((var == 10) && (count != 0))
3:    ...
4:	// Hier genügt es, wenn eine Bedingung erfüllt ist
5:	if ((var == 10) || (count != 0))
6:    ...

Die Klammern um die einzelnen Bedingungen sind nicht vorgeschrieben, aber dennoch empfehlenswert, damit es keine bösen Überraschungen in Bezug auf die Reihenfolge der Auswertung der einzelnen Operatoren gibt.

Die Anweisung

if ((AUSDRUCK1) & (AUSDRUCK2))
   ...

ist syntaktisch korrekt und erzeugt keinen Fehler beim Übersetzen des Programms. Hier werden die beiden Ausdrücke bitweise verundet und nicht logisch (was vermutlich erfolgen sollte).

constexpr if-Anweisung

Mithilfe der constexpr if-Anweisung können alternativ zu übersetzende Anweisungen in Abhängigkeit von einer Bedingung definiert werden.

if constexpr ([INIT;] BEDINGUNG)
   ANWEISUNG1;      // if-Zweig
[else
   ANWEISUNG2;]     // else-Zweig

Die Bedingung muss ein konstanter Ausdruck sein, der ein boolsches Ergebnis liefert. Im nachfolgenden Beispiel werden je nach Wert der Konstanten DEBUG_LEVEL verschiedene Ausgaben zur Verfolgung des Programmablaufs ausgegeben werden.

1:	const int DEBUG_LEVEL = 1;
2:	
3:	// main() Funktion
4:	int main()
5:	{
6:     if constexpr (DEBUG_LEVEL == 1)
7:     {
8:        std::cout << "Einfache Debug-Ausgabe.\n";
9:     }
10:    else
11:       if constexpr (DEBUG_LEVEL == 2)
12:       {
13:          std::cout << "Detaillierte Debug-Ausgabe!\n";
14:       }
15:	}

Enthält die Konstante DEBUG_LEVEL den Wert '1', erfolgt eine einfache Debug-Ausgabe und für den Fall, dass sie den Wert '2' enthält, eine detailliertere Debug-Ausgabe. In allen anderen Fällen erfolgt keine Ausgabe.

Wie erwähnt, erfolgt die Auswertung der Bedingung nicht wie bei der 'normalen' if-Abfrage zur Laufzeit des Programmes, sondern zur Compilezeit. D.h., der Compiler erzeugt je nach Inhalt der Konstanten DEBUG_LEVEL keinen Code oder den entsprechenden Code für eine einfache oder detaillierte Debug-Ausgabe.

Dieses Beispiel ist zwar nicht ganz praxisgerecht, jedoch zeigt es die Wirkung der constexpr if-Anweisung. In der Regel wird die constexpr if-Anweisung in Templates eingesetzt, um Bedingungen abzuprüfen. Mehr zu Templates später.

Bedingungsoperator und goto

Eine abgewandelte Form der if-Anweisung stellt der Bedingungsoperator dar, der folgende Syntax besitzt:

erg = (BEDINGUNG) ? AUSDRUCK1 : AUSDRUCK2;

Liefert die Auswertung von BEDINGUNG als Ergebnis true, wird AUSDRUCK1 ausgewertet und das Ergebnis der Variablen erg zugewiesen. Liefert BEDINGUNG dagegen false, wird das Ergebnis von AUSDRUCK2 der Variablen erg zugewiesen. Das folgende Beispiel zeigt, wie mithilfe dieser Anweisung der Absolutbetrag einer Variablen berechnet werden kann. Außerdem ist eine weitere, etwas unkonventionellere, if-Abfrage aufgeführt, die je nach Zustand der Variablen light entweder den Text Das Licht ist an oder den Text Das Licht ist aus ausgibt.

1:	// Absolutbetrag von var1 in var2 ablegen
2:	var2 = (var1>=0) ? var1 : -var1;
3:	// Alternative Schreibweise:
4:	// if (var1>=0)
5:	//    var2 = var1;
6:	// else
7:	//    var2 = -var1;
8:	// Weiteres (unkonventionelles) Beispiel:
9:	std::cout << "Das Licht ist " << ((light)? "an" : "aus")
10:	     << '\n';

Der Vollständigkeit halber sei an dieser Stelle erwähnt, dass es auch eine goto-Anweisung gibt. Sie hat folgende Syntax:

1:	goto label;   // Sprung nach label
2:	...
3:	label:        // Das Sprungziel

Das Sprungziel muss ein eindeutiger Namen sein und mit einem Doppelpunkt abgeschlossen werden. Für die Position des Sprungziels gibt es eine Reihe von Einschränkungen, die hier nicht weiter betrachtet werden. Ein 'sauberes' Programm kommt ohne goto aus.

Hier folgen in der Offline-Version die Übungen.