Teil 1: Grundlagen


Verzweigungen & Schleifen

if-Verzweigung

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

if ([INIT;] AUSDRUCK)
    ANWEISUNG1   // IF-Zweig
[else
    ANWEISUNG2]  // ELSE-Zweig

Ergibt die Auswertung von AUSDRUCK true, wird die Anweisung ANWEISUNG1 ausgeführt. Im anderen Fall wird entweder der optionale else-Zweig oder nichts ausgeführt. Optional kann innerhalb der if-Klammer ein optionaler Ausdruck INIT stehen, der vor der Auswertung von AUSDRUCK ausgeführt wird.

Standardmäßig folgt auf ein if oder else nur eine Anweisung. Um mehrere Anweisungen in Abhängigkeit von der Bedingung auszuführen, sind die Anweisungen in einen Block {...} einzuschließen.

 AUSDRUCK kann auch aus mehreren Bedingungen bestehen, die dann mit den entsprechenden Logikoperatoren (&&, || und !) verknüpft werden.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
    // Einzulesendes Datum
    int eingabe;
    // Datum einlesen
    cout << "Bitte geben Sie eine Integerzahl ein: ";
    cin >> eingabe;
    // Wenn eine positive Zahl eingegeben wurde
    if (eingabe > 0)
        cout << "Eingabe war eine positive Zahl.\n";
    // Zahl war nicht positiv
    else
    {
        // Wenn eine negative Zahl eingegeben wurde
        if (eingabe < 0)
            cout << "Eingabe war eine negative Zahl.\n";
        // Ansonsten war die Eingabe eine Null oder fehlerhaft
        else
            cout << "Sie haben 0 oder keine Zahl eingegeben!\n";
    }
}

ss

Bedingungsoperator und goto

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

erg = (AUSDRUCK1) ? AUSDRUCK2 : AUSDRUCK3;

Liefert die Auswertung des Ausdrucks AUSDRUCK1 als Ergebnis true, so wird AUSDRUCK2 ausgewertet und das Ergebnis der Variablen erg zugewiesen. Liefert AUSDRUCK1 dagegen false, wird das Ergebnis von AUSDRUCK3 der Variablen erg zugewiesen.

Nur der Vollständigkeit halber sei an dieser Stelle noch erwähnt, dass C++ auch eine goto-Anweisung kennt. Sie wir hier aber nicht weiter betrachtet, da ein 'sauberes' Programm ohne goto auskommt.

switch-Verzweigung

Sollen je nach Inhalt einer ganzzahligen oder char-Variable verschiedene Anweisungen durchlaufen werden, wird hierfür die switch-Verzweigung eingesetzt. Sie hat folgende Syntax:

switch ([INIT;] AUSDRUCK)
{
case K1:
    AKTION1
    [break;]
    ...
case Kx:
     AKTIONx
    [break;]
[default:
    AKTIONy]
}

Der Ablauf der switch-Verzweigung ist folgender:

  • Ist ein optionaler Initialisierungsausdruck INIT vorhanden, wird dieser zunächst ausgewertet.
  • Danach wird der Ausdruck der switch-Anweisung ausgewertet. Dieser Ausdruck muss entweder ein ganzzahliges oder char-Ergebnis liefern.
  • Anschließend wird das Ergebnis des Ausdrucks mit den Literalen verglichen, die auf das Schlüsselwort Case folgen. Stimmt das Ergebnis mit einem der angegebenen Literale überein, so werden die Anweisungen nach der entsprechenden case-Anweisung bis zur optinalen break-Anweisung ausgeführt. Die Anweisungen müssen nicht einem Klammerpaar {...} eingeschlossen sein.
  • Stimmt das Ergebnis mit keinem der aufgeführten Literale überein, so werden die Anweisungen nach der optionalen default-Anweisung ausgeführt.

Die break-Anweisung innerhalb eines switch-Blocks bewirkt ein unmittelbares Verlassen des Blocks, d.h. nach dem break wird als nächste die Anweisung ausgeführt, die nach der geschweiften Klammer zu folgt. Ohne eine break-Anweisung werden alle nach der Einsprungsmarke (case Kx:) folgenden Anweisungen bis zum Ende des switch-Blocks oder bis zum Erreichen eines break ausführt.

Und auch das ist möglich: sollen für verschiedene Werte die gleichen Anweisungen ausgeführt werden, so können mehrere case-Zweige unmittelbar aufeinanderfolgen. Die Reihenfolge der case-Anweisungen ist dabei beliebig.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
    // Variable fuer die Eingabe definieren
    char eingabe;
    // Buchstaben einlesen
    // Das Einlesen erfolgt im INIT-Ausdruck der switch-Anweisung
    // Je nach Eingabe wird ein anderer Text ausgegeben, wobei
    // nicht nach Klein-/Grossschreibung unterschieden wird
    cout << "Bitte geben Sie einen Buchstaben ein: ";
    switch (cin >> eingabe; eingabe)
    {
    case 'e':
    case 'E':
        cout << "Sie haben e oder E eingegeben!\n";
        break;
    case 'a':
    case 'A':
        cout << "Sie haben a oder A eingegeben.\n";
        break;
    default:
        cout << "Sie haben weder ein a noch ein e eingegeben.\n";
    }
}

for-Schleife

Die for-Schleife wird hauptsächlich dann eingesetzt, wenn bereits vor dem Eintritt in die Schleife die Anzahl der Schleifendurchläufe bekannt ist. Sie hat folgende Syntax:

for (AUSRUCK1; AUSDRUCK2; AUSDRUCK3)
    ANWEISUNG;

AUSDRUCK1 wird vor dem Eintritt in die Schleife ausgewertet und initialisiert in der Regel einen Schleifenzähler. AUSDRUCK2 bestimmt das Abbruchkriterium und ist üblicherweise ein vergleichender Ausdruck. Ergibt die Auswertung von AUSDRUCK2 false, wird die Schleife beendet. AUSDRUCK3 wird nach dem ausführen der Schleifenaktion ANWEISUNG ausgewertet; er inkrementiert bzw. dekrementiert den Schleifenzähler in der Regel. Alle 3 Ausdrücke sind optional. So erzeugt eine for-Schleife ohne Abbruchkriterium eine Endlosschleife.

Die Schleifenaktion ANWEISUNG besteht standardmäßig aus einer Anweisung. Sollen mehrere Anweisungen in der Schleife ausgeführt werden, so sind die Anweisungen in einem Block {...} einzuschließen.

#include <iostream>
using std::cout;
using std::endl;

int main()
{
    // Auszugebendes Datum
    short var = 0x12a5;
    // Anzahl der Bits des Datums berechnen
    const unsigned short BITS = sizeof(var) * 8;

    cout << std::hex << var << " in binaerer Form:\n";
    // Datum in binaerer Darstellung ausgeben
    // Die Schleife durchlaeuft den Bereich 1...sizeof(var)*8
    // d.h. 1...16 da eine short Variable 2 Bytes belegt
    for (auto index = 1; index <= BITS; index++)
    {
        // Aktuelles Bit ausmaskieren
        auto res = var & (1 << (BITS-index));
        // Wenn Ergebnis ungleich 0, dann eine '1' ausgeben
        // und ansonsten eine '0'
        // (cond) ? val1 : val2 ist der Bedingungsoperator!
        cout << ((res != 0) ? '1' : '0');
        // Nach jeder 4 Ausgabe ein Leerzeichen einfuegen
        if (index % 4 == 0)
            cout << ' ';
    }
}

while-Schleife

Die while-Schleife wird in erster Linie eingesetzt, wenn sich die Abbruchbedingung für die Schleife erst während eines Schleifendurchlaufs ergibt. Sie hat folgende Syntax:

while (AUSDRUCK)
    ANWEISUNG;

auch hier besteht die Schleifenaktion ANWEISUNG standardmäßig nur aus einer Anweisung. Mehrere Anweisungen sind ebenfalls in einem Block {...} einzuschließen.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
    int eingabe;           // Eingelesener Wert
    long long summe = 0;   // Summe der Werte
    int anzWerte = 0;      // Anzahl der Werte

    cout << "Es wird jetzt der Mittelwert von einzugebenen\n"
         << "Werten berechnet. Das Einlesen der Werte wird\n"
         << "beendet, wenn eine 0 eingegeben wird.\n\n";

    // Schleife zur Mittelwertberechnung
    // Wird bei Eingabe einer 0 beendet
    eingabe = 999; // Unbedingt vorbelegten mit != 0
    while (eingabe != 0)
    {
        cout << "Bitte einen int-Wert eingeben: ";
        cin >> eingabe;
        // Wenn keine 0 eingegeben wurde
        if (eingabe != 0)
        {
            // Wert aufaddieren und Anzahl Wert erhoehen
            summe += eingabe;
            anzWerte++;
        }
    };

    // Mittelwert ausgeben
    // Achtung! Daten muessen VOR der Division in
    // Gleitkomma-Daten konvertiert werden
    auto mittel = static_cast<float>(summe) / static_cast<float>(anzWerte);
    cout << "Mittelwert ist " << mittel << endl;
}

do-while-Schleife

Auch diese Schleife wird zumeist verwendet, wenn sich die Abbruchbedingung erst während eines Schleifendurchlaufs ergibt. Sie hat folgende Syntax:

do
    ANWEISUNG;
while (AUSDRUCK);

Auch hier wird die Schleife solange durchlaufen, wie die Auswertung von AUSDRUCK true ergibt und mehrere Anweisungen in der Schleife sind ebenfalls in einem Block {...} einzuschließen.

Der Unterschied zur vorherigen while-Schleife liegt darin, dass die Abbruchbedingung bei der while-Schleife vor dem Eintritt in die Schleife ausgewertet wird, während dies bei der do-while-Schleife erst nach einem Schleifendurchlauf erfolgt.

#include <iostream>
#include <fstream>
using std::cout;
using std::endl;

int main()
{
    // Zu schreibende und einzulesende Datei
    const char const *pFile = "c:\\temp\\test.dat";

    // Datei fuer Ausgabe oeffnen std::ofstream outFile(pFile);
    if (!pFile)
    {
        cout << "Fehler beim Schreiben der Datei " << pFile << endl;
        exit(1);
    }

    // Werte in Datei schreiben
    // Trennzeichen zwischen den Daten nicht vergessen!
    for (int index = 0; index < 10; index++)
        outFile << index << ' ';
    // Datei auch wieder schliessen
    outFile.close();

    // Datei fuer Eingabe oeffnen
    std::ifstream inFile(pFile);
    if (!pFile)
    {
        cout << "Fehler beim Lesen der Datei " << pFile << endl;
        exit(1);
    }

    int var; // Einzulesendes Datum
    // Daten wieder einlesen bis zum Dateiende
    cout << "Eingelesene Daten:\n";
    do
    {
        // Datum einlesen
        inFile >> var;
        // Wenn Dateiende nicht erreicht, Wert ausgeben
        if (!inFile.eof())
            cout << var << ',';
    } while (!inFile.eof());
    // Datei wieder schliessen
    inFile.close();
}

break und continue Anweisung

Eine break-Anweisung darf nur innerhalb einer Schleife oder eines case-Zweigs der switch-Verzweigung stehen. Sie bewirkt das sofortige Verlassen der Schleife bzw. der switch-Verzweigung.

Die continue-Anweisung ist nur innerhalb einer Schleife (for, while, do-while) stehen. Sie veranlasst, dass die restlichen, auf die continue-Anweisung folgenden Anweisungen, übersprungen werden. Die Schleife selbst wird aber nicht beendet.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int main()
{
    char wahl; // Einzulesendes Datum

    // Endlos-Schleife for (;;)
    {
        // Datum einlesen
        cout << "Eingabe: ";
        cin >> wahl;
        // Wenn s oder S eingegeben, Eingabe ignorieren
        if ((wahl == 's') || (wahl == 'S'))
            continue;
        // Wenn e oder E eingegeben, Schleife verlassen
        if ((wahl == 'e') || (wahl == 'E'))
            break;
        // Eingabe ausgeben
       cout << "Eingabe war " << wahl << endl;
    }
}



Copyright © cpp-tutor.de
Impressum &Datenschutz