Schleifen in C und C++ » Die for-Schleife

Schleifen zur Programmsteuerung I

Übersicht / Seite:

1. for-Schleife (mit Beispielen zur Berechnung von binären Werten)
2. while-Schleife (Unterschiede und Gemeinsamkeiten mit der for Schleife)

---

Die for-Schleife

Neben den Fallunterscheidungen gehören Schleifen zu den wichtigsten Kontroll­strukturen zur Programmsteuerung. Innerhalb einer Schleife wird ein Anweisungs­block solange wiederholt, wie die Bedingung für einen Durchlauf der Schleife erfüllt wird.
Die Syntax einer for-Schleife beruht auf der Initialisierung eines Anfangswertes im Schleifenkopf, dem ein zweiter Ausdruck zur Prüfung der Bedingung folgt und ein dritter Ausdruck, welcher der Erhöhung oder Verringerung des Anfangswertes bei jedem Schleifendurchlauf dient. Da in den meisten Programmiersprachen für den Anfangswert ein numerischer Wert gewählt wird, der dann Runde für Runde um eine Stelle hoch oder runter gezählt wird, ist die for-Schleife auch unter dem Namen Zählschleife bekannt.
Für die Erhöhung wird oftmals ein Inkrementor benutzt und für die Verringerung ein Dekrementor. Ebenso gut könnte jedoch auch eine einfache Addition oder Sub­traktion erfolgen.

for (Anfangswert; Prüfe Bedingung; Veränderung des Anfangswertes) {

    Anweisungen
}

Nachfolgend einige Beispiele, doch zuvor noch ein Hinweis. Alle Listings auf dieser Seite sind für den Datentyp int (integer) und somit nur für ganzzahlige Werte ausgelegt.

Code-Beispiele in C

Im ersten Beispiel wird der binäre Wert einer Dezimalzahl ermittelt.

for-Schleife 1: Um den binären Wert zu ermitteln, wird mit Hilfe des Modulo-Operators in der ersten Anweisung der Restwert von einer Division durch 2 ermittelt, der bei geraden Zahlen 0 und bei ungeraden 1 beträgt. In der zweiten Anweisung erfolgt dann die eigentliche Division.
Da die Zählung nicht ab 1 sondern ab 0 beginnt, wird nicht bis 8, sondern nur bis 7 gezählt bzw. überprüft, ob der Wert von i noch nicht größer als 7 ist.

for-Schleife 2: In der zweiten Schleife erfolgt eine Umkehrung der Reihenfolge, wobei im Schleifenkopf geprüft wird, ob der Zählwert von i noch nicht kleiner als 0 ist.

Ein Beispiel in C für die Berechnung des binären Wertes einer Ganzzahl:

#include <stdio.h>

int main() {

int wert = 10;
int rest[8];
int i;

    printf ("Berechnung des Bin\x84 \brwertes der Dezimalzahl 10: \r\n\r\n");

    for (i = 0; i <= 7; i++) {

        printf ("%d.) %2d : 2 = ", i, wert);      // %2d entspricht einer Dezimalzal mit 2 Stellen
        rest[i] = wert %2;                        // %2 Modulo bzw. Rest von dividiert durch 2
        wert   /= 2;                              // Der Wert dividiert durch 2
        printf ("%d (Rest %d)\n", wert, rest[i]);
    }

    printf ("\nIn 1 Byte mit 8 Bit: ");

    for (i = 7; i >= 0; i--) {

        printf ("%d", rest[i]);
    }

    getchar();
    return 0;
}

Ausgabe: Berechnung des Binärwertes einer Dezimalzahl (im Beispiel der Zahl 10)

Im nächsten Beispiel soll nicht nur für eine dezimale Ganzzahl der binäre Wert berechnet werden, sondern für eine Reihe von Zahlen. Dazu werden die beiden for-Schleifen aus dem ersten Code-Listing zu einem Anweisungsblock innerhalb einer weiteren for-Schleife zusammengefasst. Die beiden inneren Schleifen werden nun so oft ausgeführt, wie die Bedingungen für die äußere Schleife erfüllt werden. Gut ersichtlich wird aus diesem Beispiel, dass sich Schleifen beinahe beliebig ineinander verschachteln lassen.

Berechnung der Binärwerte der Zahlenreihe 1 bis 10 in C:

#include <stdio.h>

int main() {

int wert;
int rest[8];
int n, i;

    printf ("Berechnung des Bin\x84 \brwertes der Dezimalzahlen 1 bis 10: \r\n\r\n");

    for (n = 1; n <= 10; n++) {

        wert = n;
        printf ("\nWert %2d: ", wert);

        for (i = 0; i <= 7; i++) {
            rest[i] = wert %2;
            wert   /= 2;
        }
        for (i = 7; i >= 0; i--) {
            printf ("%d", rest[i]);
        }
    }

    getchar();
    return 0;
}

Bevor Verschachtelungen zu unübersichtlich werden, kann gegebenenfalls eine Auslagerung in Funktionen erfolgen, wie im dritten Beispiel geschehen. Im Ergebnis unterscheiden sich beide Konsolenanwendungen nicht, wie der weiter unten folgenden Ausgabe zu entnehmen.

Ein Beispiel mit in einer Funktion ausgelagerten for-Schleifen C:

#include <stdio.h>

void berechne_Bits(int param) {

    int rest[8];
    int i;

    for (i = 0; i <= 7; i++) {
        rest[i] = param %2;
        param  /= 2;
    }
    for (i = 7; i >= 0; i--) {
        printf("%d", rest[i]);
    }
}

int main() {

int wert;
int n;

    printf ("Bin\x84 \brwerte der Dezimalzahlen 1 bis 10: \r\n\r\n");

    for (n = 1; n <= 10; n++) {

        wert = n;
        printf ("\nWert %2d: ", wert);
        berechne_Bits(wert);
    }

    getchar();
    return 0;
}

Ausgabe der Binärwerte für die Dezimalzahlen 1 bis 10

Code-Beispiele in C++

Im Gegensatz zu C bringt C++ bereits eine geeignete Klasse mit dem Namen bitset mit sich, wobei diese Klasse diverse Methoden für unterschiedliche Aufgaben bereitstellt.
Zu den Beispielen sei bemerkt, da eine Variable vom Datentyp int unter dem Betriebssystem Windows mit 4 Byte zu je 8 Bit gespeichert wird, wurde in beiden Beispielen 32 Bits für die Instanz der Klasse bidset notiert. Weiterhin wird mit der Methode to_string der Wert bzw. das Bitset als Sring zurückgegeben.
Ferner ist erwähnenswert, dass das bitset eigentlich als eine 32-stellige Zahl ohne Leerstellen ausgegeben wird, die sich nur schlecht lesen lässt. Um die Lesbarkeit zu verbessern, wurde mit der Methode replace der Stringklasse nach jedem Byte ein Leerzeichen eingefügt.

Ein Beispiel mit der Klasse bitset und mit der String-Methode replace in C++:

#include <iostream>     // fuer cout und endl
#include <bitset>       // fuer bitset
#include <string>       // fuer replace und to_string
#include <iomanip>      // fuer setw
using namespace std;

int main() {

    string ausgabe;
    string ers_positiv = " 0";    // 0 mit einem Leerzeichen ergänzen
    string ers_negativ = " 1";    // 1 mit einem Leerzeichen ergänzen

    cout << "Positive Dezimalzahlen int 4 Byte und 32 Bit.\r\n\r\n";

    for (int i = 1; i < 21; i++) {

        bitset <32> binaer(i);
        ausgabe = binaer.to_string();

        ausgabe.replace( 8, 1, ers_positiv);
        ausgabe.replace(17, 1, ers_positiv);
        ausgabe.replace(26, 1, ers_positiv);

        cout << setw(4) << i << ": " << ausgabe << endl;
    }

    cout << "\nNegative Dezimalzahlen int 4 Byte und 32 Bit.\r\n\r\n";

    for (int i = -1; i > -11; i--) {

        bitset <32> binaer(i);
        ausgabe = binaer.to_string();

        ausgabe.replace( 8, 1, ers_negativ);
        ausgabe.replace(17, 1, ers_negativ);
        ausgabe.replace(26, 1, ers_negativ);

        cout << setw(4) << i << ": " << ausgabe << endl;
    }

    cin.get();
    return 0;
}

Das Code-Listing mit der String-Methode replace bringt einen entscheidenden Nachteil mit sich, es eignet sich nur für kleinere Ganzzahlen. Bei größeren Zahlen kann nicht vorausgesehen werden, ob eine 0 oder 1 gegen eine " 0" oder " 1" mit Leerzeichen ausgetauscht werden soll.
Dieses Manko lässt sich durch die Methode assign umgehen, mit welcher der String in 8, 16 und 24 Bit großen Häppchen in 4 einzelne Teilstrings aufgeteilt wird. Nach erfolgter Aufteilung werden die Teilstrings durch ein Leerzeichen ergänzt und wieder zusammengefügt. Um den Code nicht zweimal zu notieren, wurde dieser in eine Funktion ausgelagert.

Ein Beispiel mit der String-Methode assign in C++:

#include <iostream>     // fuer cout und endl
#include <bitset>       // fuer bitset
#include <string>       // fuer assign und to_string
#include <iomanip>      // fuer setw
using namespace std;

string teile_in_Byte(string eingang) {

    string ausgang, str1, str2, str3, str4;

    ausgang  = str1.assign(eingang,  0, 8);
    ausgang += " ";
    ausgang += str2.assign(eingang,  8, 8);
    ausgang += " ";
    ausgang += str3.assign(eingang, 16, 8);
    ausgang += " ";
    ausgang += str4.assign(eingang, 24, 8);

    return ausgang;
}

int main() {

    string ausgabe;
    int i;

    cout << "Positive Dezimalzahlen int 4 Byte und 32 Bit.\r\n\r\n";

    for (i = 1; i < 21; i++) {

        bitset <32> binaer(i);
        ausgabe = binaer.to_string();

        cout << setw(4) << i << ": " << teile_in_Byte(ausgabe) << endl;
    }

    cout << "\nNegative Dezimalzahlen int 4 Byte und 32 Bit.\r\n\r\n";

    for (i = -1; i > -11; i--) {

        bitset <32> binaer(i);
        ausgabe = binaer.to_string();

        cout << setw(4) << i << ": " << teile_in_Byte(ausgabe) << endl;
    }

    cin.get();
    return 0;
}

Ausgabe der Binärwerte für positive und negative Dezimalzahlen

weiterlesen: while-Schleife