đ
Vorlesung 5
Schleifen, Endlosschleifen und Schleifensteuerung
Fortgeschrittene Algorithmen und Programmierung
Prof. Dr. Alexandra Mikityuk
HTW Berlin WiSe 2025/26
Lernziele dieser Vorlesung
- for-Schleifen verstehen und anwenden
- while-Schleifen nutzen
- do-while-Schleifen kennenlernen
- Endlosschleifen mit break kontrollieren
- continue fĂŒr Schleifensteuerung einsetzen
- Unterschiede zwischen den Schleifenarten erkennen
- Praktische Anwendungen mit Schleifen umsetzen
Warum Schleifen?
Problem: Manuelle Wiederholung
printf("1\n");
printf("2\n");
printf("3\n");
printf("4\n");
printf("5\n");
Lösung: Schleifen!
for(int i = 1; i <= 5; i++)
{
printf("%d\n", i);
}
for-Schleife: Syntax und Komponenten
for(Initialisierung; Bedingung; Aktualisierung)
{
}
Die drei Komponenten:
- Initialisierung: Startwert festlegen (z.B.
int i = 1)
- Bedingung: Wann lÀuft die Schleife? (z.B.
i <= 5)
- Aktualisierung: Was passiert nach jedem Durchlauf? (z.B.
i++)
for-Schleife: Flussdiagramm
Initialisierung: i = 1
â
Bedingung: i <= 5 ?
â (ja)
Schleifenkörper ausfĂŒhren
â
Aktualisierung: i++
â (zurĂŒck zur Bedingung)
Bei (nein): Schleife beenden und weiter im Programm
for-Schleife: Einfaches Beispiel
Zahlen von 1 bis 5 ausgeben
#include <stdio.h>
int main()
{
for(int i = 1; i <= 5; i++)
{
printf("%d\n", i);
}
return 0;
}
for-Schleife: Einkaufsrechner
Summe von 3 Artikeln berechnen
#include <stdio.h>
int main()
{
double preis, summe = 0.0;
for(int i = 1; i <= 3; i++)
{
printf("Preis Artikel %d: ", i);
scanf("%lf", &preis);
summe += preis;
}
printf("Gesamtsumme: %.2f EUR\n", summe);
return 0;
}
for-Schleife: Wann verwenden?
Ideal fĂŒr for-Schleifen:
- Anzahl der Wiederholungen ist bekannt
- ZĂ€hlen von A bis B (z.B. 1 bis 10)
- Durchlaufen von Arrays/Listen
- Feste Anzahl von Iterationen
Beispiele:
- "Gib die Noten von 5 Studenten ein"
- "Berechne die FakultÀt von n"
- "Drucke die Zahlen von 1 bis 100"
while-Schleife: Syntax
while(Bedingung)
{
}
Funktionsweise:
- PrĂŒft zuerst die Bedingung
- FĂŒhrt Schleifenkörper aus, wenn Bedingung wahr
- Wiederholt, bis Bedingung falsch
- Kann 0-mal laufen, wenn Bedingung von Anfang an falsch ist
while-Schleife: Flussdiagramm
Bedingung prĂŒfen
â (wahr)
Schleifenkörper ausfĂŒhren
â (zurĂŒck zur Bedingung)
Bei (falsch): Schleife ĂŒberspringen/beenden
Wichtig: Wenn die Bedingung von Anfang an falsch ist, wird die Schleife nie ausgefĂŒhrt!
while-Schleife: Einkauf mit Auswahl
#include <stdio.h>
int main()
{
char weiter;
double preis, summe = 0.0;
printf("Einkaufen? (j/n): ");
scanf(" %c", &weiter);
while(weiter == 'j')
{
printf("Preis: ");
scanf("%lf", &preis);
summe += preis;
printf("Weiterer Artikel? (j/n): ");
scanf(" %c", &weiter);
}
printf("Summe: %.2f EUR\n", summe);
return 0;
}
while vs for: Unterschiede
for-Schleife
- Anzahl bekannt
- ZĂ€hler integriert
- Kompakte Syntax
- Ideal zum ZĂ€hlen
for(int i=1; i<=5; i++)
{
printf("%d ", i);
}
while-Schleife
- Anzahl unbekannt
- Freie Bedingung
- Flexibel
- Bedingungsbasiert
int i = 1;
while(i <= 5)
{
printf("%d ", i);
i++;
}
while-Schleife: Wann verwenden?
Ideal fĂŒr while-Schleifen:
- Anzahl der Wiederholungen ist nicht im Voraus festgelegt
- AbhÀngig von Benutzereingabe oder Ereignissen
- Bis eine bestimmte Bedingung erfĂŒllt ist
- "Solange wie..." Szenarien
Beispiele:
- "Lies Zahlen ein, bis der Nutzer 0 eingibt"
- "Wiederhole, bis die Eingabe gĂŒltig ist"
- "Solange Geld auf dem Konto ist..."
- "Bis der Nutzer 'Ende' eingibt"
do-while-Schleife: Syntax
do
{
} while(Bedingung);
Achtung: Semikolon am Ende!
Anders als bei while braucht do-while ein ; nach der Bedingung!
Besonderheit: Die Schleife wird mindestens einmal ausgefĂŒhrt, da die Bedingung erst nach dem ersten Durchlauf geprĂŒft wird!
do-while-Schleife: Flussdiagramm
Schleifenkörper ausfĂŒhren
â
Bedingung prĂŒfen
â (wahr: zurĂŒck zum Anfang)
Bei (falsch): Schleife beenden
Garantie: Der Schleifenkörper wird immer mindestens 1x ausgefĂŒhrt!
do-while-Schleife: Einkaufsbeispiel
#include <stdio.h>
int main()
{
char weiter;
double preis, summe = 0.0;
do
{
printf("Preis des Artikels: ");
scanf("%lf", &preis);
summe += preis;
printf("Weiterer Artikel? (j/n): ");
scanf(" %c", &weiter);
} while(weiter == 'j');
printf("Gesamtsumme: %.2f EUR\n", summe);
return 0;
}
Vorteil: Mindestens ein Artikel wird immer eingegeben!
do-while vs while: Der Unterschied
while-Schleife
Bedingung zuerst
int x = 10;
while(x < 5)
{
printf("LĂ€uft\n");
}
do-while-Schleife
Bedingung danach
int x = 10;
do
{
printf("LĂ€uft\n");
} while(x < 5);
Kernunterschied: while kann 0x laufen, do-while lÀuft mindestens 1x
Formatierte Ausgabe mit printf
Wichtige Format-Spezifizierer:
| Format |
Bedeutung |
Beispiel |
%d |
Integer |
42 |
%6d |
Integer, 6 Stellen breit |
42 |
%.2f |
Float, 2 Nachkommastellen |
3.14 |
%8.2f |
Float, 8 Stellen breit, 2 Nachkomma |
3.14 |
Tabellen mit Schleifen erstellen
#include <stdio.h>
int main()
{
printf("Nr. Quadrat\n");
printf("---------------\n");
for(int i = 1; i <= 10; i++)
{
printf("%3d %6d\n", i, i*i);
}
return 0;
}
Ausgabe:
Nr. Quadrat
---------------
1 1
2 4
3 9
4 16
5 25
...
Eingabevalidierung mit do-while
Typisches Muster: Eingabe wiederholen bis gĂŒltig
#include <stdio.h>
int main()
{
int alter;
do
{
printf("Bitte Alter eingeben (1-120): ");
scanf("%d", &alter);
if(alter < 1 || alter > 120)
printf("UngĂŒltige Eingabe!\n");
} while(alter < 1 || alter > 120);
printf("Alter: %d Jahre\n", alter);
return 0;
}
Komplexere Validierung
Aufgabe:
Lies einen Preis ein und stelle sicher, dass:
- Die Eingabe eine gĂŒltige Zahl ist (nicht "abc" o.Ă€.)
- Der Preis zwischen 0.01 und 1000.00 EUR liegt
- Bei Fehler: Fehlermeldung und erneut fragen
Lösung - Zwei PrĂŒfungen kombinieren:
- Ist die Eingabe eine Zahl? (scanf-RĂŒckgabewert)
- Ist die Zahl im erlaubten Bereich? (0.01-1000.00)
Komplexere Validierung: Code
#include <stdio.h>
int main() {
double preis;
int gueltig;
do {
printf("Preis eingeben (0.01-1000.00 EUR): ");
if(scanf("%lf", &preis) != 1)
{
printf("Fehler: Keine gĂŒltige Zahl!\n");
while(getchar() != '\n');
gueltig = 0;
}
else if(preis < 0.01 || preis > 1000.0)
{
printf("Fehler: Preis auĂerhalb des Bereichs!\n");
gueltig = 0;
}
else { gueltig = 1; }
} while(!gueltig);
printf("Preis: %.2f EUR\n", preis);
return 0;
}
Verschachtelte Schleifen
Schleifen können ineinander verschachtelt werden
#include <stdio.h>
int main()
{
printf("Kleines Einmaleins:\n\n");
for(int zeile = 1; zeile <= 5; zeile++)
{
for(int spalte = 1; spalte <= 5; spalte++)
{
printf("%4d", zeile * spalte);
}
printf("\n");
}
return 0;
}
Ausgabe: 1 2 3 4 5 / 2 4 6 8 10 / 3 6 9 12 15 / ...
Endlosschleifen (Infinite Loops)
Was ist eine Endlosschleife?
Eine Schleife, die nie von selbst endet, weil die Bedingung immer wahr ist.
while(1)
{
}
for(;;)
{
}
do
{
} while(1);
Achtung: Endlosschleifen sind nicht immer ein Fehler! Manchmal sind sie gewollt (z.B. MenĂŒs, Server).
break - Schleife vorzeitig verlassen
Was macht break?
Das break-Statement beendet die Schleife sofort.
Das Programm lÀuft nach der Schleife weiter.
#include <stdio.h>
int main()
{
for(int i = 1; i <= 10; i++)
{
if(i == 5)
{
break;
}
printf("%d ", i);
}
printf("\nFertig!\n");
return 0;
}
break mit Endlosschleife
Typisches Muster: Menu-Programm
#include <stdio.h>
int main()
{
int wahl;
while(1)
{
printf("\n=== MENU ===\n");
printf("1. Option A\n");
printf("2. Option B\n");
printf("0. Beenden\n");
printf("Wahl: ");
scanf("%d", &wahl);
if(wahl == 0)
{
break;
}
printf("Option %d gewÀhlt\n", wahl);
}
printf("Programm beendet.\n");
return 0;
}
continue - Rest des Durchlaufs ĂŒberspringen
Was macht continue?
Das continue-Statement ĂŒberspringt den Rest des aktuellen Durchlaufs und springt direkt zur nĂ€chsten Iteration.
#include <stdio.h>
int main()
{
for(int i = 1; i <= 10; i++)
{
if(i % 2 == 0)
{
continue;
}
printf("%d ", i);
}
return 0;
}
break vs continue: Der Unterschied
break
Beendet die Schleife
for(int i = 1; i <= 5; i++)
{
if(i == 3)
break;
printf("%d ", i);
}
printf("Ende");
continue
Ăberspringt Rest des Durchlaufs
for(int i = 1; i <= 5; i++)
{
if(i == 3)
continue;
printf("%d ", i);
}
printf("Ende");
Merke: break = raus aus der Schleife, continue = weiter zur nÀchsten Runde
Praxis: Suche mit break
Zahl in Liste suchen
#include <stdio.h>
int main()
{
int zahlen[] = {23, 45, 12, 89, 34, 56};
int gesucht = 89;
int gefunden = 0;
for(int i = 0; i < 6; i++)
{
if(zahlen[i] == gesucht)
{
printf("Gefunden an Position %d!\n", i);
gefunden = 1;
break;
}
}
if(!gefunden)
printf("Nicht gefunden.\n");
return 0;
}
Vorteil: Sobald gefunden, wird die Schleife beendet. Keine unnötigen weiteren Vergleiche!
Vergleich: Welche Schleife wann?
| Schleifentyp |
Wann verwenden? |
Besonderheit |
| for |
Feste Anzahl von DurchlÀufen |
ZĂ€hler integriert |
| while |
Bedingungsbasiert, kann 0x laufen |
Bedingung zuerst |
| do-while |
Bedingungsbasiert, mind. 1x |
Bedingung am Ende |
| while(1) + break |
Endlosschleife mit Ausstiegsbedingung |
Flexible Steuerung |
Faustregel:
- for: "Mache N mal..."
- while: "Solange wie..."
- do-while: "Mache mindestens einmal, dann solange wie..."
- break: "Stopp die Schleife jetzt!"
- continue: "Ăberspringe den Rest und mache weiter!"
HĂ€ufige Fehler vermeiden
1. Ungewollte Endlosschleifen
int i = 0;
while(i < 10)
{
printf("%d\n", i);
}
2. Semikolon nach for/while
for(int i = 0; i < 5; i++);
{
printf("Hallo\n");
}
HĂ€ufige Fehler vermeiden (2)
3. Semikolon bei do-while vergessen
do
{
printf("Test\n");
} while(x < 5)
Richtig:
do
{
printf("Test\n");
} while(x < 5);
Zusammenfassung
Was wir gelernt haben:
- for: Bekannte Anzahl von Wiederholungen
- while: Bedingungsbasierte Wiederholung (0 oder mehr mal)
- do-while: Mindestens einmal ausfĂŒhren
- Endlosschleifen + break: Flexible Schleifensteuerung
- continue: DurchlĂ€ufe ĂŒberspringen
- Formatierte Ausgaben mit printf
- Eingabevalidierung mit Schleifen
- Verschachtelte Schleifen fĂŒr Tabellen
Kontakt
Prof. Dr. Alexandra Mikityuk
BĂŒro: Raum C308
Sprechstunde: Mittwoch 15:30-16:30