Schleifen

Verzweigungen durch if und else haben wir bereits kennengelernt. Damit lässt sich der Programmfluss in gewissen Grenzen steuern. Wenn wir jedoch denselben Programmcode wiederholt mit verschiedenen Werten durchlaufen lassen wollen, benötigen wir Schleifen.

Die while-Schleife

Das einfachste Konstrukt in C++, das uns dies erlaubt, ist die while-Schleife:

// Schleife: Solange die Bedingung erfüllt ist,
// wiederhole den Block. Ist die Bedingung am Anfang
// nicht erfüllt, wird der Block gar nicht ausgeführt.
while( Bedingung )
{
    Befehle;
}

// Alternative: Führe den Block aus und prüfe
// am Ende, ob die Bedingung erfüllt ist. Hierbei
// wird der Block mindestens einmal ausgeführt.
do
{
    Befehle;

} while( Bedingung );


// Beispiel: die Zahlen eins bis zehn ausgeben
unsigned int i = 1;
while( i <= 10 )
{
    cout << i << endl;
    i++;
}

Die for-Schleife

Die for-Schleife wird normalerweise verwendet, um Zahlen auf- oder Abwärts zu zählen. Wie wir gesehen haben, lässt sich dafür auch eine while-Schleife verwenden, die Schreibweise der for-Schleife ist aber etwas kompakter. Folgende Codefragmente bedeuten dasselbe:

// for-Schleife mit Initialisierung, Bedingung und
// einem Befehl, der am Ende jedes Schleifendurchlaufs
// aufgerufen wird.
for( Initialisierung; Bedingung; EndBefehl )
{
    Befehle;
}

// Dasselbe in Grün, hier mit einer while-Schleife
{
    Initialisierung;
    while( Bedingung )
    {
        Befehle;
        Endbefehl;
    }
}

// Beispiel: die Zahlen eins bis zehn ausgeben
for( unsigned int i = 1; i <= 10; i++ )
{
    cout << i << endl;
}

Warum ist die entsprechende while-Schleife noch einmal in geschweifte Klammern gesetzt? Wie auf der letzten Seite über Funktionen angedeutet, hat dies mit dem Gültigkeitsbereich von Variablen zu tun. Die Variable i, die wir innerhalb der for-Schleife deklariert haben, ist ausserhalb der Schleife ungültig.

Zur Sache

Rein hypothetisch: Was ist das kleinste gemeinsame Vielfache von 123 und 321? Naja, was solls, schreiben wir eben ein Programm, das so etwas herausfinden kann...

Im Kopf können wir uns die Aufgabe vielleicht so zurechtlegen: Zähle von eins an aufwärts und probiere bei jeder Zahl, ob die Division durch 123 und 321 gleichzeitig den Rest Null ergibt. Das Programm soll die entsprechende Zahl ausgeben und abbrechen, wenn sie gefunden wurde.

Geradeheraus programmiert sähe unsere Lösung für das kleinest gemeinsame Vielfache so aus:

#include <iostream>
using namespace std;

int main()
{
    // Deklariere und initialisiere eine
    // Variable zum Hochzählen (Laufvariable)
    unsigned int i = 1;

    // Schleife: Solange i kleiner oder gleich
    // 123*321, wiederhole den Block
    while (i <= 123*321)
    {
        // Prüfe, ob sich die Laufvariable i
        // durch beide Zahlen ohne Rest teilen lässt
        if( (i%123)==0 && (i%321)==0 )
        {
            // Gebe das Ergebnis aus
            cout << "Ergebnis: " << i << endl;
            // Beende das Programm
            return 0;
        }

        // Erhöhe Laufvariable um eins
        i = i + 1;
    }
   
    // Bis hierhin wird das Programm nicht laufen...
    // trotzdem sauber zurückgehen
    return 0;
}

Wir fragen im Beispiel zwei Dinge ab, nämlich ob der Rest von i durch 123 Null ist UND der Rest von i durch 321 Null ist. Das geht aber schöner.

Schreiben wir eine neue Funktion, die das kleinste gemeinsame Vielfache beliebiger Zahlen finden kann und außerdem die praktische for-Schleife verwendet.

#include <iostream>
using namespace std;

// Berechne das kleinste gemeinsame Vielfache von a und b
unsigned int kgv(unsigned int a, unsigned int b)
{
    // Schleife (kgv jedenfalls <= a*b)
    for (unsigned int i = 1; i <= a*b; i++)
    {
        // Prüfe, ob sich die Laufvariable
        // durch beide Zahlen ohne Rest teilen lässt
        if( (i%a)==0 && (i%b)==0 )
        {
            // Gebe das Ergebnis zurück
            return i;
        }
    }

    // Fehler zurückgeben, z.B. wenn a==0 oder b==0
    return 0;
}

int main()
{
    cout << "kgv(123, 321) = " << kgv(123, 321) << endl;
    cout << "kgv(234, 432) = " << kgv(234, 432) << endl;
    return 0;
}

Die Funktion trägt den Namen kgv. In der Klammer dahinter sind die zwei Eingabeparameter a und b von Typ unsigned int angegeben. Der Rückgabewert der Funktion ist wieder ein ganzzahliger, nichtnegativer Wert (links vom Funktionsnamen), in unserem Fall eben das kleinste gemeinsame Vielfache von a und b.

In unserer Hauptroutine main rufen wir dann die Funktion zwei Mal auf, einmal für 123 und 312 und danach für 234 und 432.

zurück