647 lines
16 KiB
Markdown
647 lines
16 KiB
Markdown
# 🎓 Interaktiver Programmierkurs: Von C zu universellen Konzepten
|
||
|
||
*Ein Kurs für C/C++-Einsteiger mit Fokus auf übertragbare Programmierkonzepte*
|
||
|
||
---
|
||
|
||
## 📋 Kursübersicht
|
||
|
||
**Zielgruppe:** Student mit C-Grundlagen, geplantem C++-Umstieg
|
||
**Kursdauer:** 8 Wochen (selbstgewähltem Tempo)
|
||
**Lernziel:** Sprachunabhängige Programmierkonzepte verstehen und auf beliebige Sprachen anwenden
|
||
|
||
---
|
||
|
||
## 🗺️ Modul-Struktur
|
||
|
||
```
|
||
Woche 1-2: Grundlagen & Denkweisen
|
||
├── Modul 1: Das Memory-Modell (Stack vs Heap)
|
||
├── Modul 2: Datentypen als Konzepte (nicht Syntax)
|
||
└── Checkpoint A: Selbsteinschätzung
|
||
|
||
Woche 3-4: Kontrollstrukturen & Logik
|
||
├── Modul 3: Flusskontrolle universell
|
||
├── Modul 4: Funktionen als Abstraktion
|
||
└── Checkpoint B: Mini-Projekt #1
|
||
|
||
Woche 5-6: Datenstrukturen
|
||
├── Modul 5: Arrays, Listen, Strukturen
|
||
├── Modul 6: Pointer & Referenzen verstehen
|
||
└── Checkpoint C: Datenstruktur-Implementierung
|
||
|
||
Woche 7-8: OOP & Fortgeschrittenes
|
||
├── Modul 7: Von structs zu Objekten (C → C++ → Konzept)
|
||
├── Modul 8: Modularisierung & Design Patterns
|
||
└── Final-Projekt: Sprachunabhängige Anwendung
|
||
```
|
||
|
||
---
|
||
|
||
## 🧠 Modul 1: Das Memory-Modell
|
||
|
||
### Konzept: Speicher ist universell
|
||
|
||
**In C:**
|
||
```c
|
||
int stack_var = 42; // Stack - automatisch verwaltet
|
||
int* heap_var = malloc(4); // Heap - manuell verwaltet
|
||
*heap_var = 42;
|
||
free(heap_var); // Nicht vergessen!
|
||
```
|
||
|
||
**Das universelle Konzept:**
|
||
> **Stack** = Kurzlebig, automatisch, schnell
|
||
> **Heap** = Langfristig, manuell/verwaltet, flexibel
|
||
|
||
### 🎯 Interaktive Übung 1.1: Memory-Map
|
||
|
||
Zeichne ein Diagramm:
|
||
|
||
```
|
||
┌─────────────────┐ High Address
|
||
│ Stack │ ← Wachst nach unten (lokal vars)
|
||
│ ↓ │
|
||
│ │
|
||
│ ↑ │
|
||
│ Heap │ ← Wachst nach oben (malloc/new)
|
||
│ (freier │
|
||
│ Speicher) │
|
||
│ │
|
||
│ Static/Data │ ← Globale Variablen, Strings
|
||
│ (Programm) │
|
||
└─────────────────┘ Low Address
|
||
```
|
||
|
||
**Frage:** Was passiert bei dieser C-Code Sequenz?
|
||
|
||
```c
|
||
void foo() {
|
||
int a = 10; // Wo landet das?
|
||
int *b = malloc(sizeof(int)); // Und das?
|
||
*b = 20;
|
||
// b vergessen zu free()
|
||
}
|
||
```
|
||
|
||
<details>
|
||
<summary>Antwort anzeigen</summary>
|
||
|
||
- `a` → **Stack** (automatisch gelöscht nach foo())
|
||
- `b` → **Stack** (nur der Pointer!)
|
||
- `*b` (der Wert 20) → **Heap**
|
||
- ⚠️ **Memory Leak**: *b bleibt im Heap, weil free() vergessen wurde
|
||
|
||
**Universelles Konzept:** Jede Sprache hat Stack/Heap. Python/Java haben Garbage Collection, C/C++ nicht, Rust hat Ownership.
|
||
</details>
|
||
|
||
---
|
||
|
||
## 🔢 Modul 2: Datentypen als Konzepte
|
||
|
||
### Konzept: Typen sind Speicher + Operationen
|
||
|
||
**Nicht lernen:** "int ist 4 Bytes"
|
||
**Lernen:** "int ist ein ganzzahliger Typ mit begrenztem Bereich"
|
||
|
||
### 🎯 Interaktive Übung 2.1: Typ-Universum
|
||
|
||
Ordne diese Konzepte zu:
|
||
|
||
| Konzept | C | C++ | Python | Java | JavaScript |
|
||
|---------|---|---|--------|------|------------|
|
||
| Ganzzahl (fix) | `int` | `int` | - | `int` | `Number` |
|
||
| Ganzzahl (beliebig) | `long long` | `long long` | `int` | `BigInteger` | `BigInt` |
|
||
| Fließkomma | `float` | `float` | `float` | `float` | `Number` |
|
||
| Hochpräzision | `double` | `double` | `float` | `double` | - |
|
||
| Wahrheitswert | `bool` (C99) | `bool` | `bool` | `boolean` | `boolean` |
|
||
| Text | `char[]` | `string` | `str` | `String` | `string` |
|
||
|
||
**Erkenntnis:** Konzepte sind gleich, Syntax variiert!
|
||
|
||
### 🧪 Praxis 2.2: Typische Fehler
|
||
|
||
```c
|
||
// C-Fehler
|
||
int a = 2147483647;
|
||
int b = a + 1; // Was ist b nun?
|
||
```
|
||
|
||
**Antwort:** Überlauf (Overflow). `b` wird -2147483648 (Integer Overflow)
|
||
|
||
**Universelles Konzept:** Alle Typen haben Grenzen. Kenne deine Grenzen!
|
||
|
||
---
|
||
|
||
## 🔄 Modul 3: Flusskontrolle universell
|
||
|
||
### Konzept: Programme = Sequenz + Auswahl + Wiederholung
|
||
|
||
**Strukturdiagramm:**
|
||
|
||
```
|
||
SEQUENZ
|
||
│
|
||
▼
|
||
┌──────┐
|
||
│Aktion│
|
||
└──────┘
|
||
│
|
||
▼
|
||
┌──────┐
|
||
│Aktion│
|
||
└──────┘
|
||
|
||
AUSWAHL (if/else)
|
||
│
|
||
▼
|
||
┌────────┐
|
||
│Bedingung?│
|
||
└────────┘
|
||
│Ja │Nein
|
||
▼ ▼
|
||
┌────┐ ┌────┐
|
||
│Dann│ │Sonst│
|
||
└────┘ └────┘
|
||
|
||
WIEDERHOLUNG (loops)
|
||
│
|
||
▼
|
||
┌──────────┐
|
||
│Bedingung?│←────┐
|
||
└──────────┘ │
|
||
│Ja │Nein
|
||
▼ │
|
||
┌──────┐ │
|
||
│Body │─────────┘
|
||
└──────┘
|
||
```
|
||
|
||
### 🎯 Interaktive Übung 3.1: Struktur erkennen
|
||
|
||
Welche Struktur hat dieser Code?
|
||
|
||
```c
|
||
// Code A
|
||
for (int i = 0; i < 10; i++) {
|
||
if (i % 2 == 0) continue;
|
||
printf("%d ", i);
|
||
}
|
||
|
||
// Code B
|
||
int x = 5;
|
||
if (x > 0) {
|
||
if (x < 10) {
|
||
printf("Im Bereich");
|
||
}
|
||
}
|
||
|
||
// Code C
|
||
while (1) {
|
||
char c = getchar();
|
||
if (c == 'q') break;
|
||
process(c);
|
||
}
|
||
```
|
||
|
||
<details>
|
||
<summary>Lösungen</summary>
|
||
|
||
- **Code A:** Wiederholung (for) + Auswahl (if) + Sprung (continue)
|
||
- **Code B:** Verschachtelte Auswahl (nested if)
|
||
- **Code C:** Endlosschleife (while(1)) + Abbruchbedingung (break)
|
||
|
||
**Universell:** `for`, `while`, `if`, `break`, `continue` existieren in fast allen Sprachen mit ähnlicher Semantik.
|
||
</details>
|
||
|
||
---
|
||
|
||
## 🔧 Modul 4: Funktionen als Abstraktion
|
||
|
||
### Konzept: Funktionen kapseln Komplexität
|
||
|
||
**Analogie:** Funktion = Rezept
|
||
- **Eingabe:** Zutaten (Parameter)
|
||
- **Prozess:** Anleitung (Funktionskörper)
|
||
- **Ausgabe:** Gericht (Return-Wert)
|
||
|
||
### 🎯 Interaktive Übung 4.1: Black-Box-Denken
|
||
|
||
Betrachte diese Funktion:
|
||
|
||
```c
|
||
int mystery(int a, int b) {
|
||
int result = 0;
|
||
while (b != 0) {
|
||
if (b & 1) result += a;
|
||
a <<= 1;
|
||
b >>= 1;
|
||
}
|
||
return result;
|
||
}
|
||
```
|
||
|
||
**Ohne Code zu analysieren:** Was könnte diese Funktion tun?
|
||
|
||
<details>
|
||
<summary>Tipp + Lösung</summary>
|
||
|
||
**Tipp:** Teste mit Werten:
|
||
- `mystery(3, 4)` → ?
|
||
- `mystery(5, 5)` → ?
|
||
|
||
**Lösung:** Es ist die **ägyptische Multiplikation** (schnelle Multiplikation ohne `*`).
|
||
|
||
**Konzept:** Funktionen sind Black Boxes. Verstehe Input/Output, nicht unbedingt Implementation.
|
||
</details>
|
||
|
||
### 🧪 Praxis 4.2: Design by Contract
|
||
|
||
```c
|
||
/**
|
||
* Berechnet den Durchschnitt eines Arrays.
|
||
*
|
||
* PRECONDITION: array != NULL, size > 0
|
||
* POSTCONDITION: Rückgabe = Summe(array) / size
|
||
*
|
||
* @param array Nicht-leeres Array von double
|
||
* @param size Anzahl der Elemente (> 0)
|
||
* @return Durchschnittswert
|
||
*/
|
||
double average(const double* array, size_t size);
|
||
```
|
||
|
||
**Universelles Konzept:** Design by Contract (Eiffel, aber überall anwendbar)
|
||
|
||
---
|
||
|
||
## 📦 Modul 5: Datenstrukturen
|
||
|
||
### Konzept: Strukturen organisieren Daten
|
||
|
||
**Evolution:**
|
||
|
||
```c
|
||
// 1. Primitive
|
||
int score = 100;
|
||
|
||
// 2. Array (Sammlung gleicher Typen)
|
||
int scores[5] = {100, 95, 87, 92, 88};
|
||
|
||
// 3. Struct (Zusammengesetzter Typ)
|
||
typedef struct {
|
||
char name[50];
|
||
int scores[5];
|
||
float average;
|
||
} Student;
|
||
|
||
// 4. Dynamische Struktur (Linked List)
|
||
typedef struct Node {
|
||
Student data;
|
||
struct Node* next;
|
||
} Node;
|
||
```
|
||
|
||
**Universelle Datenstrukturen:**
|
||
| Struktur | Verwendung | Sprachen |
|
||
|----------|-----------|----------|
|
||
| Array | Indexierter Zugriff | Alle |
|
||
| Linked List | Einfügen/Löschen | C, C++, Java |
|
||
| Stack | LIFO (Undo, Parsing) | Alle (meist builtin) |
|
||
| Queue | FIFO (Scheduling) | Alle |
|
||
| Hash Map | Schlüssel-Wert Lookup | Python, JS, Java, C++ |
|
||
| Tree | Hierarchien | Alle |
|
||
|
||
### 🎯 Interaktive Übung 5.1: Struktur wählen
|
||
|
||
**Szenarien:** Welche Datenstruktur?
|
||
|
||
1. **Browser-History (Back/Forward)** → ?
|
||
2. **Druck-Warteschlange** → ?
|
||
3. **Wörterbuch (Wort → Definition)** → ?
|
||
4. **DOM-Elemente einer Webseite** → ?
|
||
|
||
<details>
|
||
<summary>Antworten</summary>
|
||
|
||
1. **Stack** (LIFO - letzter Besuch zuerst zurück)
|
||
2. **Queue** (FIFO - erste Anfrage zuerst drucken)
|
||
3. **Hash Map/Dictionary** (O(1) Lookup)
|
||
4. **Tree** (hierarchische Struktur, Parent-Child)
|
||
|
||
**Konzept:** Datenstrukturen sind sprachunabhängige Muster!
|
||
</details>
|
||
|
||
---
|
||
|
||
## 🎯 Modul 6: Pointer & Referenzen
|
||
|
||
### Konzept: Indirektion ist universell
|
||
|
||
**Die 3 Ebenen:**
|
||
|
||
```
|
||
Wert ──────→ Variable ──────→ Pointer
|
||
│ │ │
|
||
│ │ │
|
||
▼ ▼ ▼
|
||
42 int x int* p
|
||
x = 42 p = &x
|
||
*p = 42
|
||
```
|
||
|
||
**In verschiedenen Sprachen:**
|
||
|
||
| Sprache | Konzept | Syntax |
|
||
|---------|---------|--------|
|
||
| C | Pointer | `int* p = &x;` |
|
||
| C++ | Reference | `int& r = x;` |
|
||
| Python | Name/Referenz | `a = b` (referenziert selbes Objekt) |
|
||
| Java | Reference | `Object o = obj;` |
|
||
| Rust | Borrowing | `&x` (immutable), `&mut x` (mutable) |
|
||
| Go | Pointer | `p := &x` |
|
||
|
||
### 🎯 Interaktive Übung 6.1: Pointer-Diagramm
|
||
|
||
Zeichne für diesen Code:
|
||
|
||
```c
|
||
int a = 5;
|
||
int b = 10;
|
||
int* p = &a;
|
||
int* q = &b;
|
||
p = q;
|
||
*p = 20;
|
||
```
|
||
|
||
**Fragen:**
|
||
1. Was ist `a`?
|
||
2. Was ist `b`?
|
||
3. Was ist `*p`?
|
||
4. Was ist `*q`?
|
||
|
||
<details>
|
||
<summary>Diagramm + Lösung</summary>
|
||
|
||
```
|
||
Initial:
|
||
┌─────┐ ┌─────┐
|
||
│ a │ 5 │ b │ 10
|
||
│(0x100)│ │(0x104)│
|
||
└─────┘ └─────┘
|
||
|
||
p = &a:
|
||
┌─────┐
|
||
│ p │───→ ┌─────┐
|
||
│(0x200)│ │ a │ 5
|
||
└─────┘ └─────┘
|
||
|
||
q = &b:
|
||
┌─────┐
|
||
│ q │───→ ┌─────┐
|
||
│(0x204)│ │ b │ 10
|
||
└─────┘ └─────┘
|
||
|
||
p = q:
|
||
┌─────┐
|
||
│ p │──┐
|
||
│(0x200)│ │
|
||
└─────┘ │
|
||
┌─────┐ │
|
||
│ q │─┼┘
|
||
│(0x204)│ ┌─────┐
|
||
└─────┘ └──→│ b │ 10
|
||
│(0x104)│
|
||
└─────┘
|
||
|
||
*p = 20:
|
||
┌─────┐
|
||
│ b │ 20 ←── p und q zeigen hierhin!
|
||
│(0x104)│
|
||
└─────┘
|
||
```
|
||
|
||
**Antworten:**
|
||
1. `a` = 5 (unverändert!)
|
||
2. `b` = 20 (verändert via *p)
|
||
3. `*p` = 20
|
||
4. `*q` = 20
|
||
|
||
**Konzept:** Pointer sind Adressen. Mehrere Pointer können auf dieselbe Adresse zeigen (Aliasing).
|
||
</details>
|
||
|
||
---
|
||
|
||
## 🏗️ Modul 7: Von structs zu Objekten
|
||
|
||
### Konzept: Daten + Verhalten = Objekt
|
||
|
||
**Evolution in C → C++:**
|
||
|
||
```c
|
||
// C: Daten und Funktionen getrennt
|
||
typedef struct {
|
||
float x, y;
|
||
} Point;
|
||
|
||
float point_distance(Point* a, Point* b) {
|
||
return sqrt((a->x - b->x) ** 2 + ...);
|
||
}
|
||
```
|
||
|
||
```cpp
|
||
// C++: Daten und Verhalten zusammen
|
||
class Point {
|
||
private:
|
||
float x, y;
|
||
|
||
public:
|
||
Point(float x, float y) : x(x), y(y) {}
|
||
|
||
float distanceTo(const Point& other) const {
|
||
return sqrt((x - other.x) ** 2 + ...);
|
||
}
|
||
};
|
||
```
|
||
|
||
**Universelles OOP-Konzept:**
|
||
- **Kapselung:** Daten schützen (private/public)
|
||
- **Abstraktion:** Wie etwas funktioniert ist egal
|
||
- **Vererbung:** "Ein Hund IST EIN Tier"
|
||
- **Polymorphie:** Gleiche Schnittstelle, verschiedene Implementationen
|
||
|
||
### 🎯 Interaktive Übung 7.1: OOP-Konzepte zuordnen
|
||
|
||
```cpp
|
||
class Animal {
|
||
public:
|
||
virtual void speak() = 0; // Was ist das?
|
||
};
|
||
|
||
class Dog : public Animal { // Was ist das?
|
||
private:
|
||
string name; // Was ist das?
|
||
|
||
public:
|
||
void speak() override { // Was ist das?
|
||
cout << "Wuff!" << endl;
|
||
}
|
||
};
|
||
```
|
||
|
||
<details>
|
||
<summary>Lösungen</summary>
|
||
|
||
- `virtual ... = 0` → **Abstrakte Methode** (Polymorphie)
|
||
- `class Dog : public Animal` → **Vererbung** (Dog IST EIN Animal)
|
||
- `private: string name` → **Kapselung** (Daten geschützt)
|
||
- `void speak() override` → **Polymorphe Implementation**
|
||
|
||
**Konzept:** Diese 4 Prinzipien existieren in Python, Java, C#, Ruby, Swift... nur Syntax variiert!
|
||
</details>
|
||
|
||
---
|
||
|
||
## 🎨 Modul 8: Modularisierung & Design
|
||
|
||
### Konzept: Trennung von Belangen (Separation of Concerns)
|
||
|
||
**Schichten-Architektur (universell):**
|
||
|
||
```
|
||
┌─────────────────────────────┐
|
||
│ Presentation │ ← UI, Output
|
||
│ (View/Controller) │
|
||
├─────────────────────────────┤
|
||
│ Business Logic │ ← Verarbeitung
|
||
│ (Model/Services) │
|
||
├─────────────────────────────┤
|
||
│ Data Access │ ← Datenbank, Files
|
||
│ (Repository/DAO) │
|
||
├─────────────────────────────┤
|
||
│ Infrastructure │ ← Logging, Config
|
||
│ (Utils/Helpers) │
|
||
└─────────────────────────────┘
|
||
```
|
||
|
||
**In C:**
|
||
```
|
||
src/
|
||
├── main.c # Einstieg
|
||
├── ui/ # Presentation
|
||
│ ├── display.c
|
||
│ └── input.c
|
||
├── core/ # Business Logic
|
||
│ ├── calculator.c
|
||
│ └── validator.c
|
||
├── data/ # Data Access
|
||
│ ├── file_io.c
|
||
│ └── database.c
|
||
└── utils/ # Infrastructure
|
||
├── logger.c
|
||
└── config.c
|
||
```
|
||
|
||
**In C++:**
|
||
```
|
||
src/
|
||
├── main.cpp
|
||
├── view/ # Presentation (MVC)
|
||
├── controller/ # Flow Control
|
||
├── model/ # Business Logic
|
||
├── repository/ # Data Access
|
||
└── utils/ # Infrastructure
|
||
```
|
||
|
||
### 🎯 Interaktive Übung 8.1: Design Patterns
|
||
|
||
**Wähle das passende Pattern:**
|
||
|
||
| Problem | Pattern | Beschreibung |
|
||
|---------|---------|--------------|
|
||
| Genau eine DB-Verbindung | Singleton | Nur eine Instanz erlaubt |
|
||
| Verschiedene Zahlungsmethoden | Strategy | Austauschbare Algorithmen |
|
||
| Objekte ohne `new` erstellen | Factory | Zentralisierte Erstellung |
|
||
| Schritte A → B → C ausführen | Template Method | Algorithmus-Skelett |
|
||
|
||
**Konzept:** Design Patterns sind sprachunabhängige Lösungen für wiederkehrende Probleme!
|
||
|
||
---
|
||
|
||
## 🚀 Final-Projekt: Sprachunabhängige Anwendung
|
||
|
||
### Aufgabe: Todo-App mit mehreren Implementationen
|
||
|
||
**Anforderungen (sprachunabhängig):**
|
||
1. CRUD-Operationen für Todos
|
||
2. Speicherung (File oder Memory)
|
||
3. CLI-Interface
|
||
4. Modularer Aufbau
|
||
|
||
**Implementiere in:**
|
||
- **Version A:** C (Structs, Function Pointers)
|
||
- **Version B:** C++ (Klassen, STL)
|
||
- **(Optional) Version C:** Python oder JavaScript
|
||
|
||
**Der Test:** Vergleiche die Implementationen. Welche Konzepte sind gleich? Was unterscheidet sich?
|
||
|
||
---
|
||
|
||
## 📝 Checkpoints & Selbsteinschätzung
|
||
|
||
### Checkpoint A (nach Modul 2)
|
||
**Fragen:**
|
||
- [ ] Ich kann Stack vs Heap erklären
|
||
- [ ] Ich kenne die Grenzen primitiver Typen
|
||
- [ ] Ich verstehe, warum Konzepte wichtiger sind als Syntax
|
||
|
||
### Checkpoint B (nach Modul 4)
|
||
**Mini-Projekt:** Schreibe einen Taschenrechner mit:
|
||
- Menü (Sequenz/Auswahl)
|
||
- Mathematische Funktionen (Abstraktion)
|
||
- Fehlerbehandlung
|
||
|
||
### Checkpoint C (nach Modul 6)
|
||
**Datenstruktur:** Implementiere eine dynamische Liste (wie `std::vector` oder Python `list`) in C mit:
|
||
- `void list_append(List* list, int value)`
|
||
- `int list_get(List* list, size_t index)`
|
||
- `void list_remove(List* list, size_t index)`
|
||
|
||
### Final Check
|
||
- [ ] Ich kann Konzepte auf neue Sprachen übertragen
|
||
- [ ] Ich verstehe OOP-Prinzipien
|
||
- [ ] Ich kann modularen Code strukturieren
|
||
|
||
---
|
||
|
||
## 📚 Ressourcen & Weiterführendes
|
||
|
||
### Bücher
|
||
- **"The C Programming Language"** (K&R) - Klassiker
|
||
- **"C++ Primer"** (Lippman) - Umfassend
|
||
- **"Clean Code"** (Martin) - Sprachunabhängig!
|
||
- **"Design Patterns"** (Gang of Four) - Das Original
|
||
|
||
### Online
|
||
- **exercism.org** - Sprachübergreifende Übungen
|
||
- **leetcode.com** - Algorithmen in beliebiger Sprache
|
||
- **codewars.com** - Katas für verschiedene Sprachen
|
||
|
||
### Praxis-Tipp
|
||
> Lerne eine zweite Sprache parallel! Wenn du C lernst, schau dir Python-Äquivalente an. Die Kontraste machen die Konzepte klarer.
|
||
|
||
---
|
||
|
||
## 🎯 Abschluss
|
||
|
||
**Die wichtigste Erkenntnis:**
|
||
|
||
> Programmieren ist nicht das Lernen von Syntax. Es ist das Verstehen von Konzepten, die in jeder Sprache wiederkehren – nur mit anderem "Akzent".
|
||
|
||
Wenn du diesen Kurs durchgearbeitet hast, kannst du:
|
||
- Jede neue Sprache schneller lernen (Konzepte bereits bekannt)
|
||
- Bessere Architektur-Entscheidungen treffen
|
||
- Sprachübergreifend als Entwickler arbeiten
|
||
|
||
**Viel Erfolg! 🚀**
|