Unit 19 – Modularisierung von Programmen

Ömer sagt:

Ein großes Programm besteht aus vielen kleinen Funktionen – wie ein Haus aus Ziegeln. Jede Funktion hat eine Aufgabe. Das macht den Code lesbar, wartbar und testbar. Das ist professionelles Programmieren! 🏗️

Single Responsibility Prinzip Funktionen als Bausteine Eingabe/Verarbeitung/Ausgabe trennen Hilfsfunktionen schreiben Top-Down Design

🏗️ Modularisierung – Das Prinzip

Gute Programme sind in kleine, klare Einheiten aufgeteilt. Jede Funktion macht genau eine Sache und macht sie gut:

Single Responsibility Prinzip

Jede Funktion soll nur eine Aufgabe haben. Eine Funktion, die Eingaben liest, berechnet UND ausgibt, ist zu groß. Teile sie auf!

💻 Schlechtes vs. gutes Design

❌ MONOLITH

int main() {
  // Alles in main:
  // - Eingabe lesen
  // - Prüfen
  // - Berechnen
  // - Ausgeben
  // - Speichern
  // → 200 Zeilen!
}

✅ MODULAR

int   eingabe_lesen();
int   ist_gueltig(int);
float berechne(int);
void  ausgeben(float);

int main() {
  int x = eingabe_lesen();
  if(ist_gueltig(x))
    ausgeben(berechne(x));
}

💻 Vollständiges modulares Programm

modular_notenrechner.cC

#include <stdio.h>

/* Eingabe */
int lese_punkte() {
    int p;
    printf("Punkte (0-100): ");
    scanf("%d", &p);
    return p;
}

/* Verarbeitung */
int punkte_zu_note(int punkte) {
    if (punkte >= 87) return 1;
    if (punkte >= 75) return 2;
    if (punkte >= 63) return 3;
    if (punkte >= 50) return 4;
    return 5;
}

/* Ausgabe */
void zeige_ergebnis(int punkte, int note) {
    printf("%d Punkte → Note %d\n", punkte, note);
}

/* Koordination */
int main() {
    int p = lese_punkte();
    int n = punkte_zu_note(p);
    zeige_ergebnis(p, n);
    return 0;
}

🎯 EVA-Prinzip in Funktionen

Phase	Funktion	Aufgabe
Eingabe	`lese_*()`	Daten vom Benutzer einlesen, zurückgeben
Verarbeitung	`berechne_()`, `pruefe_()`	Daten verarbeiten, Ergebnis zurückgeben
Ausgabe	`zeige_()`, `drucke_()`	Ergebnis anzeigen, nichts zurückgeben

✏️ Übungen

Übung 1

Aufgaben aufteilen

Ein Programm soll Temperatur in Celsius einlesen, in Fahrenheit umrechnen und das Ergebnis ausgeben. Welche Funktionen würdest du erstellen? Nenne Namen und Signaturen:

Übung 2 – Programm

Modularer Taschenrechner

Schreibe einen Taschenrechner nach dem EVA-Prinzip. Erstelle Funktionen für: Eingabe (zwei Zahlen + Operator), Berechnung (switch für +,-,*,/), Ausgabe (Ergebnis anzeigen).

#include <stdio.h> /* Eingabe-Funktion */ void lese_eingabe(float *a, float *b, char *op) { printf("Zahl 1: "); scanf("%f", a); printf("Operator: "); scanf(" %c", op); printf("Zahl 2: "); scanf("%f", b); } /* Berechnungs-Funktion */ float berechne(float a, float b, char op) { switch (op) { /* +, -, *, / implementieren */ default: return 0; } } /* Ausgabe-Funktion */ void zeige_ergebnis(float a, char op, float b, float res) { printf("%.2f %c %.2f = %.2f\n", a, op, b, res); } int main() { float a, b, res; char op; lese_eingabe(&a, &b, &op); res = berechne(a, b, op); zeige_ergebnis(a, op, b, res); return 0; }

Übung 3 – Bonus

Temperatur-Konverter modular

Baue einen modularen Temperatur-Konverter nach dem EVA-Prinzip. Drei Funktionen: Eingabe, Umrechnung, Ausgabe. Unterstütze beide Richtungen (C→F und F→C):

#include <stdio.h> float celsius_zu_fahrenheit(float c) { return c * 9.0f / 5.0f + 32.0f; } float fahrenheit_zu_celsius(float f) { return (f - 32.0f) * 5.0f / 9.0f; } void zeige_konvertierung(float wert, char richtung) { if (richtung == 'C') printf("%.1f C = %.1f F\n", wert, celsius_zu_fahrenheit(wert)); else printf("%.1f F = %.1f C\n", wert, fahrenheit_zu_celsius(wert)); } int main() { float wert; char richtung; printf("Wert: "); scanf("%f", &wert); printf("C oder F? "); scanf(" %c", &richtung); zeige_konvertierung(wert, richtung); return 0; }

Jede Funktion hat genau eine Aufgabe. main() koordiniert nur. So kann man jede Funktion einzeln testen und wiederverwenden!