← Startseite
🔁

Vorlesung 6

Schleifen
for, while, do-while — Wiederholungen automatisieren

Grundlagen der Programmierung
Prof. Dr. Alexandra Mikityuk
HTW Berlin

for while do-while

Lernziele

  • Verstehen, warum Schleifen unverzichtbar sind
  • Die drei C-Schleifen for, while, do-while kennen und unterscheiden
  • Eine Schleife Schritt fĂźr Schritt nachvollziehen — ohne sie auszufĂźhren
  • break und continue richtig einsetzen
  • Die häufigsten Fallen erkennen: Endlosschleife, Off-by-One
  • Geschachtelte Schleifen verstehen und fĂźr einfache Muster nutzen

Wozu eigentlich Schleifen?

Stellt euch vor, ihr sollt „Hallo!" fünfmal auf den Bildschirm schreiben — ohne Schleifen:

😤 Ohne Schleife

printf("Hallo!\n");
printf("Hallo!\n");
printf("Hallo!\n");
printf("Hallo!\n");
printf("Hallo!\n");

Und bei tausend Wiederholungen? 1000 Zeilen Code? Niemals.

✨ Mit Schleife

for (int i=0; i<5; i++) {
    printf("Hallo!\n");
}

Drei Zeilen — und für 1000 ändert sich nur eine Zahl. Daher: Schleifen.

Merke: jede Wiederholung im Alltag ist eine Schleife — Treppe steigen, Geschirr spülen, Tabelle zeilenweise lesen. Schleifen sind der Mechanismus, mit dem Programme „viel" tun, ohne „viel Code" zu sein.

Drei Schleifen-Arten in C

🔢 for

„Wiederhole genau n-mal." Wenn ich vorher weiß, wie oft.

for (i=0; i<n; i++)

⏳ while

„Wiederhole solange die Bedingung wahr ist." Wenn ich nicht weiß, wie oft.

while (bedingung)

🔁 do-while

Wie while — aber mindestens einmal garantiert. Bedingung wird am Ende geprüft.

do {…} while (bedingung)

Wichtig: alle drei sind gleich mächtig — du könntest jede Schleife mit jeder Form schreiben. Wir wählen die, die unsere Absicht am klarsten ausdrückt.

Die for-Schleife — Aufbau

Drei Teile in einer Zeile — alle in Klammern, durch Semikolons getrennt.

for (int i = 0;  i < 5;  i++) {
       ↑               ↑          ↑
       ① Initialisierung  ② Bedingung  ③ Schritt
    printf("Hallo!\n");
}

① Init

Wird einmal ausgefßhrt, ganz am Anfang. Hier wird typisch der Zähler gesetzt.

② Bedingung

Wird vor jedem Durchgang geprüft. Solange wahr → weitermachen.

③ Schritt

Wird nach jedem Durchgang ausgefßhrt. Bringt den Zähler weiter.

for-Schleife — Ablauf Schritt für Schritt

Reihenfolge: Init → Check → Body → Schritt → Check → Body → … → Check (nein) → Ende.

① init (i=0)
↓
② check: i < 3 ?
↓ ja
Body ausfĂźhren
↓
③ schritt: i++
↓ zurück zu Check
② check: i < 3 ?
— nein →
Ende
Trace-Tabelle fĂźr for (int i=0; i<3; i++) printf("%d ", i);
Durchgangi vor CheckBedingungAusgabenach Schritt
100 < 3 ✓0i = 1
211 < 3 ✓1i = 2
322 < 3 ✓2i = 3
—33 < 3 ✗—Schleife endet

for-Schleife — Praxisbeispiel

// Gib die Zahlen 1 bis 5 mit ihrem Quadrat aus
#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 5; i++) {
        printf("%d hoch 2 = %d\n", i, i*i);
    }
    return 0;
}
Ausgabe:
1 hoch 2 = 1
2 hoch 2 = 4
3 hoch 2 = 9
4 hoch 2 = 16
5 hoch 2 = 25
Achtung: wir haben i <= 5 geschrieben (kleiner-gleich), damit die 5 dabei ist. Mit i < 5 hätten wir nur 1 bis 4.

Die while-Schleife

„Solange das wahr ist — mach weiter." Nutzen wir, wenn wir vorher nicht wissen, wie oft.

// Zähle Eingaben, bis der Benutzer 0 eingibt
int zahl = 1;
int anzahl = 0;

while (zahl != 0) {
    printf("Gib eine Zahl (0 = Stop): ");
    scanf("%d", &zahl);
    if (zahl != 0) anzahl++;
}

printf("Du hast %d Zahlen eingegeben\n", anzahl);
Wichtig: wir setzen zahl = 1 vor der Schleife, damit die Bedingung beim ersten Check schon definiert ist. Sonst wäre zahl uninitialisiert — Zufallswert → unvorhersagbares Verhalten.

while-Schleife — Ablauf

Sehr einfacher Ablauf: erst prĂźfen, dann ausfĂźhren.

check: bedingung ?
↓ ja
Body ausfĂźhren
↓ zurück zu Check
check: bedingung ?
— nein →
Ende
Wenn die Bedingung beim ersten Check schon falsch ist, wird der Body überhaupt nicht ausgeführt — die Schleife läuft 0-mal. Beispiel: while (5 > 10) macht nichts.
Daher die Faustregel:
  • for — wenn ich die Anzahl der Wiederholungen vorher kenne
  • while — wenn die Anzahl von Daten oder Eingaben abhängt

Die do-while-Schleife

Wie while — aber der Body läuft mindestens einmal. Die Bedingung wird erst am Ende geprüft.

// Frag nach einer Zahl zwischen 1 und 10 — bis sie passt
int zahl;

do {
    printf("Gib eine Zahl zwischen 1 und 10: ");
    scanf("%d", &zahl);
} while (zahl < 1 || zahl > 10);

printf("Danke: %d\n", zahl);
Klassische Anwendung: Eingaben validieren. Wir wollen den Nutzer mindestens einmal fragen — auch wenn er die Bedingung „falsche Zahl" gar nicht erfüllt, weil er noch nichts eingegeben hat.
Achtung — Semikolon! Nach while (...) am Ende von do-while steht ein Semikolon. Bei „normalem" while nicht.

do-while — Ablauf

Anderer Pfad: erst tun, dann fragen.

Body ausfĂźhren
↓
check: bedingung ?
↓ ja → zurück zum Body
Body ausfĂźhren
↓
check: bedingung ?
— nein →
Ende
Garantie: der Body läuft immer mindestens einmal — egal was die Bedingung sagt. Daher nutzt man do-while für „mindestens einmal fragen / tun".

Vergleich — wann nehme ich welche?

SchleifeBedingung geprßftMind. DurchläufeTypische Nutzung
forvor Body0Zähler-basiert: „mache n-mal" (Arrays durchlaufen, von 1 bis 100 zählen)
whilevor Body0Daten-basiert: „solange noch Eingabe da ist", „solange Datei nicht zu Ende"
do-whilenach Body1Eingabe-Validierung: „frage mindestens einmal — wiederhole bis OK"
Pragmatisch: 80% aller Schleifen sind for. while ist die zweithäufigste. do-while ist selten — meist für Eingabe-Kontrolle.

Schleifensteuerung: break & continue

🛑 break — sofort raus

for (int i=0; i<10; i++) {
    if (i == 5) break;
    printf("%d ", i);
}
// Ausgabe: 0 1 2 3 4

Verlässt die Schleife komplett. Was nach der Schleife steht, läuft normal weiter.

⏭️ continue — überspringen

for (int i=0; i<6; i++) {
    if (i % 2 == 0) continue;
    printf("%d ", i);
}
// Ausgabe: 1 3 5

Springt zum nächsten Durchgang. Die Schleife läuft weiter — nur dieser Body wird abgebrochen.

Tipp: nicht übertreiben — viele break/continue machen Code schwerer zu lesen. Wenn möglich, formuliere die Bedingung direkt um.

Geschachtelte Schleifen

Eine Schleife in einer Schleife. Die innere läuft pro äußeren Durchgang komplett durch.

for (int i = 1; i <= 3; i++) {           // äußere Schleife
    for (int j = 1; j <= 3; j++) {       // innere Schleife
        printf("(%d,%d) ", i, j);
    }
    printf("\n");
}
Ausgabe:
(1,1) (1,2) (1,3)
(2,1) (2,2) (2,3)
(3,1) (3,2) (3,3)
Rechnung: äußere Schleife läuft 3-mal. Innere läuft pro äußerem Durchgang 3-mal. → 3 × 3 = 9 Iterationen insgesamt. Geschachtelte Schleifen multiplizieren sich.

Muster mit geschachtelten Schleifen

Mit zwei verschachtelten Schleifen lassen sich elegante Muster erzeugen — z.B. ein Dreieck:

Code

for (int i=1; i<=5; i++) {
    for (int j=1; j<=i; j++) {
        printf("* ");
    }
    printf("\n");
}

Ausgabe

*
* *
* * *
* * * *
* * * * *
Trick: die innere Schleife hängt vom Wert der äußeren ab (j <= i). Daher wächst jede Zeile um ein Sternchen.

⚠️ Die Endlosschleife

Klassischer Bug: die Bedingung wird nie falsch. Programm hängt → Ctrl+C drücken.

😱 Schritt vergessen

int i = 0;
while (i < 10) {
    printf("Hilfe!\n");
    // i wird nie hochgezählt!
}

→ druckt „Hilfe!" für immer.

😱 Falsche Richtung

for (int i=10; i > 0; i++) {
    // i++ statt i--
    printf("%d ", i);
}

→ i wird immer größer, nie kleiner als 0.

Prüf-Reflex vor jedem Run: wird die Variable in der Bedingung im Body aktiv verändert? Wenn nicht — Endlosschleife in den Genen.

⚠️ Off-by-One — der häufigste Schleifen-Fehler

„Hätte ich nicht 5 ausgeben sollen?" — falsche Bedingungs-Grenze.

CodeWas du wolltestWas du bekommstFix
for (i=0; i<5; i++)1 bis 50, 1, 2, 3, 4for (i=1; i<=5; i++)
for (i=1; i<5; i++)1 bis 51, 2, 3, 4 (5 fehlt!)i<=5
for (i=0; i<=5; i++)5 Stück6 Stück (0–5)i<5
Faustregel für Arrays: Arrays in C sind 0-indexiert — bei einem Array mit 10 Elementen sind die Indizes 0 bis 9. Daher fast immer: for (int i = 0; i < n; i++).

Beispiel: Summe 1 + 2 + … + n

// Berechne 1 + 2 + … + 100
int summe = 0;
for (int i = 1; i <= 100; i++) {
    summe = summe + i;     // gleichwertig: summe += i;
}
printf("Summe: %d\n", summe);   // 5050
Was hier neu ist: der „Akkumulator" summe wird in jedem Durchgang verändert — nicht nur der Zähler i. Das ist das Muster für „etwas mit jedem Element machen".
Wichtig: summe muss vor der Schleife auf 0 gesetzt werden — sonst zählt der erste Durchgang einen Zufallswert dazu.

Beispiel: Countdown rßckwärts

// Zähle rückwärts von 10 bis 1, dann „Liftoff!"
for (int i = 10; i >= 1; i--) {
    printf("%d… ", i);
}
printf("🚀 Liftoff!\n");
Ausgabe:
10… 9… 8… 7… 6… 5… 4… 3… 2… 1… 🚀 Liftoff!
Drei Änderungen zur Aufwärts-Schleife: Startwert hoch (10), Bedingung umgedreht (>=), Schritt negativ (i--).

🤔 Mini-Quiz

Wie viele Sterne werden ausgegeben?

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        printf("*");
    }
}
A) 3
B) 4
C) 7
D) 12
Warum: geschachtelte Schleifen multiplizieren sich. Äußere läuft 3-mal, innere pro äußerem Durchgang 4-mal → 3 × 4 = 12 Sterne.

Zusammenfassung

  • Schleifen automatisieren Wiederholungen — der Kern jedes nicht-trivialen Programms.
  • for fĂźr zähler-basierte Wiederholungen, while fĂźr bedingungs-basierte, do-while wenn der Body mindestens einmal laufen muss.
  • break verlässt die Schleife, continue Ăźberspringt einen Durchgang.
  • Geschachtelte Schleifen multiplizieren sich — n × m Iterationen. (Vorblick auf Big-O in der Fortgeschrittene-Vorlesung 5!)
  • Die zwei Top-Bugs: Endlosschleife (Variable wird nicht verändert) und Off-by-One (eine Iteration zu viel oder zu wenig).

📚 Übung & Hausaufgabe

Lab 5 (im Anschluss)

Schleifen-Praxis in C: kleine Programme mit for, while und do-while bauen. Plus eure Git/GitHub-Setup mit SSH.

Hausaufgabe bis nächste Woche

  • Schreibe ein Programm, das die Fakultät von n berechnet (n! = 1 ¡ 2 ¡ 3 ¡ … ¡ n). Tipp: Akkumulator, aber Start ist 1 statt 0.
  • Schreibe ein Zahlenrate-Spiel: das Programm denkt sich eine Zahl 1–100 aus, du rätst — Schleife läuft, bis du richtig liegst.
  • Erstelle ein Einmaleins fĂźr die Zahl 7 (also 7×1=7 bis 7×10=70) mit einer for-Schleife.

Vorblick: nächste Vorlesung

In Vorlesung 7 kombinieren wir Schleifen mit der nächsten großen Idee:

  • Arrays — eine Sammlung von Werten in einer einzigen Variable
  • Strings — Arrays von Zeichen (Texte!)
  • Schleifen + Arrays = die Standardkombination der Programmierung
Spoiler: 90% aller Algorithmen, die ihr je schreiben werdet, sind „Schleife über Array". Heute habt ihr die Hälfte gelernt.

Vielen Dank!

Fragen?

Prof. Dr. Alexandra Mikityuk

HTW Berlin ¡ Bßro Raum 308

Tel +49 30 5019-2664

Nächste Woche: Arrays & Strings

1 / …