C++ For-Schleife: Syntax, Beispiele und häufige Fehler

Warum eine for-Schleife

Ein switch wählt einen Zweig aus, der einmal ausgeführt wird. Aber echte Programme müssen etwas wiederholt tun: jede Punktzahl ausgeben, eine Liste von Zahlen summieren, 10 Zeilen eines Rasters zeichnen. Die for-Schleife ist das Arbeitstier von C++, um Code eine bekannte Anzahl von Malen zu wiederholen, mit einem eingebauten Zähler, den du steuerst.

Alles, was eine for-Schleife braucht, steckt in einem kompakten Kopf, sodass die ganze Geschichte von „wie oft und wie" auf einen Blick sichtbar ist.

Der dreiteilige Kopf

Der Kopf einer for-Schleife hat drei durch Semikolons getrennte Teile: eine Initialisierung, eine Bedingung und eine Aktualisierung.

for (initializer; condition; update) {
    // Rumpf - läuft, solange die Bedingung wahr ist
}

Sie werden in einer bestimmten Reihenfolge ausgeführt: Die Initialisierung läuft einmal zu Beginn; dann wird die Bedingung vor jeder Iteration geprüft; der Rumpf läuft nur, wenn die Bedingung true ist; und die Aktualisierung läuft am Ende jeder Iteration, kurz bevor die Bedingung erneut geprüft wird.

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        cout << "i = " << i << "\n";
    }
    cout << "done\n";
}

Hier läuft int i = 0 einmal. Dann wird i < 5 geprüft: Solange es gilt, gibt der Rumpf aus und i++ erhöht den Zähler. Wenn i den Wert 5 erreicht, ist die Bedingung false, also verlässt die Schleife den Lauf und done wird ausgegeben. Der Rumpf läuft genau 5-mal, wobei i die Werte 0 bis 4 annimmt.

Den Zähler im Kopf zu deklarieren (int i = 0) hält i auf die Schleife begrenzt - es existiert nach der schließenden Klammer nicht mehr, was genau das ist, was du willst.

Hoch-, runter- und in Schritten zählen

Der Aktualisierungsteil ist nicht auf i++ beschränkt. Du kannst runterzählen, in beliebiger Schrittweite vorrücken oder über einen Array-Index iterieren.

#include <iostream>
using namespace std;

int main() {
    // runterzählen
    for (int i = 5; i > 0; i--) {
        cout << i << " ";
    }
    cout << "liftoff\n";

    // in 2er-Schritten (gerade Zahlen)
    for (int n = 0; n <= 10; n += 2) {
        cout << n << " ";
    }
    cout << "\n";
}

Die erste Schleife läuft, solange i > 0, und verringert jedes Mal, sodass sie 5 4 3 2 1 ausgibt. Die zweite addiert bei jedem Durchlauf 2 und verwendet <= 10, weil 10 ein Wert ist, den wir einschließen wollen. Passe deine Bedingung zu deiner Aktualisierung: Runterzählen passt zu > oder >=, Hochzählen zu < oder <=.

Über ein Array iterieren

Die häufigste Verwendung einer Zählschleife ist das Durchlaufen eines Arrays per Index. Der Zähler dient zugleich als die Position, die du liest.

#include <iostream>
using namespace std;

int main() {
    int scores[] = {88, 92, 75, 60, 100};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        total += scores[i];
    }

    cout << "Sum: " << total << "\n";
    cout << "Average: " << total / n << "\n";
}

Beachte, dass die Bedingung i < n lautet, nicht i <= n. Ein Array mit 5 Elementen hat gültige Indizes 0 bis 4; Index 5 liegt hinter dem Ende. scores[5] zu lesen ist undefiniertes Verhalten - es kann Müll ausgeben, abstürzen oder scheinbar funktionieren und stillschweigend Speicher beschädigen. Das Muster i < n ist die sichere Voreinstellung für jedes nullbasierte Array.

Wenn du nur die Werte und nicht den Index brauchst, ist eine bereichsbasierte for-Schleife sauberer. Greife zur klassischen indizierten Schleife, wenn du die Position tatsächlich brauchst.

break und continue

Zwei Schlüsselwörter erlauben dir, den Ablauf mitten in der Schleife zu ändern. break verlässt die Schleife sofort; continue überspringt den Rest der aktuellen Iteration und springt zur Aktualisierung.

#include <iostream>
using namespace std;

int main() {
    // bei der ersten durch 7 teilbaren Zahl stoppen
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            cout << "First multiple of 7: " << i << "\n";
            break;
        }
    }

    // nur ungerade Zahlen ausgeben, die geraden überspringen
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        cout << i << " ";
    }
    cout << "\n";
}

Die erste Schleife stoppt in dem Moment, in dem sie 7 findet, und prüft den Rest nie. Die zweite verwendet continue, um die Ausgabe im Rumpf zu überspringen, wann immer i gerade ist - die Aktualisierung i++ läuft trotzdem, sodass die Schleife weiter vorrückt. Ein subtiler Fallstrick: continue springt zur Aktualisierung, wenn du dich also je auf continue in einer Schleife verlässt, deren Zähler im Rumpf statt im Kopf aktualisiert wird, kannst du diese Aktualisierung versehentlich überspringen und dich endlos drehen.

Verschachtelte Schleifen

Setze ein for in ein anderes, um mit Rastern, Tabellen oder Paaren zu arbeiten. Die innere Schleife läuft bei jedem einzelnen Schritt der äußeren Schleife vollständig durch.

#include <iostream>
using namespace std;

int main() {
    for (int row = 1; row <= 3; row++) {
        for (int col = 1; col <= 3; col++) {
            cout << row * col << "\t";
        }
        cout << "\n";
    }
}

Dies gibt ein 3x3-Multiplikationsraster aus. Die äußere Schleife fixiert eine row, die innere Schleife durchläuft jede col für diese Zeile, dann beendet ein Zeilenumbruch die Zeile. Gib den Zählern unterschiedliche Namen (row/col, nicht i/i) - denselben Namen wiederzuverwenden verdeckt den äußeren und erzeugt verwirrende Bugs. Achte auch auf die Kosten: Eine n-Schleife in eine n-Schleife zu verschachteln, führt den Rumpf n * n-mal aus, was sich schnell summiert.

Häufige Fallstricke

Ein paar Fallen erklären die meisten for-Schleifen-Bugs in C++:

• Off-by-one: i <= n mit einer nullbasierten Größe liest ein Element hinter dem Ende. Verwende i < n.
• Unsigned-Unterlauf: Runterzählen mit einem vorzeichenlosen Typ wird nie negativ. for (size_t i = n - 1; i >= 0; i--) läuft endlos, weil i >= 0 für einen vorzeichenlosen Wert immer wahr ist - wenn i 0 ist, springt i-- auf eine riesige positive Zahl um. Verwende für absteigende Zählungen ein vorzeichenbehaftetes int oder schreibe die Bedingung um.
• Den Zähler im Rumpf verändern: i sowohl im Rumpf als auch im Kopf zu ändern, macht die Anzahl der Schleifendurchläufe unvorhersehbar. Wähle einen Ort.

// BUG: infinite loop - unsigned i is never < 0
for (size_t i = n - 1; i >= 0; i--) {
    process(arr[i]);
}

Gleitkommazähler sind eine weitere stille Gefahr: for (double x = 0.0; x != 1.0; x += 0.1) trifft möglicherweise nie genau 1.0, weil 0.1 nicht präzise gespeichert werden kann. Iteriere mit einer Ganzzahl-Zählung und berechne den Wert im Inneren, oder verwende < statt !=.

Als Nächstes: while-Schleifen

Die for-Schleife glänzt, wenn du die Anzahl im Voraus kennst. Aber manchmal musst du wiederholen, bis sich eine Bedingung ändert - Eingabe bis zum Dateiende lesen, bis zum Erfolg erneut versuchen - ohne eine feste Anzahl von Schritten. Das ist die Aufgabe der while-Schleife, die den Kopf auf eine einzige Bedingung reduziert. Sie ist die nächste Seite.