
Ömer sagt:
Modularisierung ist das Geheimnis professioneller Software. Kleine Funktionen, klare Aufgaben – das ist der Unterschied zwischen 'Code der funktioniert' und 'Code der wartbar ist'!
Single Responsibility
Eine Funktion – eine Aufgabe
Jede Funktion soll genau eine Sache erledigen. Eine Funktion die Eingabe liest, berechnet UND ausgibt ist zu groß. Teile sie in drei auf!
EVA-Prinzip in Funktionen
| Phase | Funktion | Aufgabe |
|---|---|---|
| Eingabe | lese_*() | scanf + return |
| Verarbeitung | berechne_*() | Rechnen + return Ergebnis |
| Ausgabe | zeige_*() | printf, void |
modular.cC
float celsius_zu_fahrenheit(float c) { return c*9.0f/5.0f+32; } void zeige_temp(float c, float f) { printf("%.1f°C = %.1f°F\n", c, f); } int main() { float c = 100.0f; zeige_temp(c, celsius_zu_fahrenheit(c)); }
Namenskonventionen für Funktionen
| Muster | Bedeutung | Beispiele |
|---|---|---|
| verb_nomen() | Aktion auf Objekt | berechne_bmi(), lese_zahl(), zeige_ergebnis() |
| ist_*()/pruefe_*() | Ja/Nein-Frage | ist_prim(), pruefe_eingabe() |
| hole_*()/lese_*() | Eingabe | hole_name(), lese_punkte() |
| berechne_*()/kalkuliere_*() | Verarbeitung | berechne_steuer() |
| zeige_*()/drucke_*() | Ausgabe | zeige_menue(), drucke_tabelle() |
Praktisches Beispiel – Notenprogramm vollständig
Ein vollständig modulares Programm nach dem EVA-Prinzip: jede Funktion hat genau eine Aufgabe, main() koordiniert nur den Ablauf.
notenprogramm.cC
int lese_punkte() { int p; printf("Punkte (0-100): "); scanf("%d", &p); return p; } int punkte_zu_note(int p) { if (p >= 90) return 1; if (p >= 75) return 2; if (p >= 60) return 3; if (p >= 50) return 4; return 5; } void zeige_ergebnis(int p, int note) { printf("%d Punkte → Note %d\n", p, note); } int main() { int p = lese_punkte(); zeige_ergebnis(p, punkte_zu_note(p)); return 0; }
⚡ Code-Simulator
Schreibe eigene Funktionen und teste sie – der Simulator zeigt printf-Ausgaben:
C Simulator – Unit 19 – Funktionen
▶ Ausgabe
– Klicke AUSFÜHREN –

Ömer sagt:
Schreibe eigene Funktionen und ändere die Argumente beim Aufruf. So siehst du direkt wie Funktionen Daten verarbeiten!
🎯 Wissens-Quiz
Frage 1
Was bedeutet 'Single Responsibility Prinzip'?
Frage 2
Was ist das EVA-Prinzip?
Frage 3
Welche Funktion im EVA-Prinzip gibt typischerweise void zurück?
Frage 4
Was ist der Vorteil kleiner, spezialisierter Funktionen?
Frage 5
Was macht main() in einem modularen Programm?
Frage 6
Was besagt das Single-Responsibility-Prinzip?
Frage 7
Was steht das "E" im EVA-Prinzip?
Frage 8
Welche Funktion übernimmt die Rolle des "Koordinators" in einem modularen Programm?
📋 Spickzettel
Modularisierung
1 Funktion = 1 AufgabeSingle Responsibility
Eingabe lesenlese_*() → return
Verarbeitenberechne_*() → return
Ausgebenzeige_*() → void
Gutes Design
Klein & übersichtlichMax ~20 Zeilen/Funktion
Sprechende Namenberechne_bmi() statt f()
Keine SeiteneffekteNur eigene Vars
TestbarJede Fn einzeln testen
✅ Checkliste Unit 19
- Ich kann ein Programm nach EVA in Funktionen aufteilen
- Ich kenne das Single Responsibility Prinzip
- Ich kann Eingabe-, Verarbeitungs- und Ausgabe-Funktionen schreiben
- Ich verstehe warum modularer Code besser wartbar ist