diff --git a/docs/quiz-fragen.md b/docs/quiz-fragen.md new file mode 100644 index 0000000..71d7891 --- /dev/null +++ b/docs/quiz-fragen.md @@ -0,0 +1,679 @@ +# 📝 Quizfragen: Programmierkonzepte universell + +*Interaktive Selbsttests fĂŒr jedes Modul* + +--- + +## Modul 1: Memory-Modell + +### Frage 1.1 +**Was passiert mit dieser Variable nach Ende der Funktion?** + +```c +void test() { + int x = 42; + int *p = &x; +} +``` + +- [ ] A) `x` bleibt im Speicher, `p` zeigt auf ungĂŒltigen Bereich +- [ ] B) `x` wird automatisch freigegeben (Stack), `p` ist danach ungĂŒltig +- [ ] C) `x` muss mit `free()` freigegeben werden +- [ ] D) `p` enthĂ€lt weiterhin die gĂŒltige Adresse von `x` + +
+Antwort + +**B)** `x` liegt auf dem Stack und wird beim Verlassen der Funktion automatisch freigegeben. `p` enthĂ€lt dann eine ungĂŒltige Adresse (Dangling Pointer). + +**Konzept:** Stack-Variablen haben automatische Lebensdauer (Scope-basiert). +
+ +### Frage 1.2 +**Welche Zuordnung ist korrekt?** + +| Speicherbereich | Eigenschaft | +|-----------------|-------------| +| Stack | A) Manuell verwaltet, persistent | +| Heap | B) Automatisch verwaltet, kurzlebig | + +- [ ] A) Stack=A, Heap=B +- [ ] B) Stack=B, Heap=A + +
+Antwort + +**B)** Stack = Automatisch verwaltet (B), Heap = Manuell verwaltet (A) + +**Konzept:** Stack (automatisch, schnell, begrenzt) vs Heap (manuell/verwaltet, flexibel, langsam). +
+ +### Frage 1.3 +**Code-Analyse:** + +```c +void foo() { + int *a = malloc(sizeof(int) * 100); + // ... Nutzung von a ... + free(a); + *a = 42; // ⚠ Was ist das Problem? +} +``` + +- [ ] A) Speicherleck (Memory Leak) +- [ ] B) Use-after-free +- [ ] C) Stack Overflow +- [ ] D) Buffer Overflow + +
+Antwort + +**B)** Use-after-free: Nach `free(a)` ist der Speicher ungĂŒltig. Der Zugriff `*a = 42` ist undefiniertes Verhalten. + +**Konzept:** Pointer bleibt bestehen, aber der Speicher dahinter ist freigegeben. +
+ +--- + +## Modul 2: Datentypen + +### Frage 2.1 +**Welcher C-Datentyp hat typischerweise die grĂ¶ĂŸte Reichweite?** + +- [ ] A) `int` (32-bit) +- [ ] B) `short` (16-bit) +- [ ] C) `long long` (64-bit) +- [ ] D) `float` (32-bit) + +
+Antwort + +**C)** `long long` ist 64-bit und kann daher den grĂ¶ĂŸten ganzzahligen Bereich darstellen (~±9×10Âč⁞). + +**Konzept:** TypgrĂ¶ĂŸe = Wertebereich. Float hat zwar auch 32-bit, aber fĂŒr Fließkommazahlen. +
+ +### Frage 2.2 +**Was ist der Unterschied zwischen `char` und `int8_t`?** + +- [ ] A) `int8_t` ist grĂ¶ĂŸer +- [ ] B) `char` ist garantiert 8-bit, `int8_t` variiert +- [ ] C) `int8_t` ist garantiert 8-bit, `char` kann variieren +- [ ] D) Kein Unterschied, beide sind identisch + +
+Antwort + +**C)** `int8_t` (aus ``) garantiert exakt 8-bit. `char` ist laut C-Standard mindestens 8-bit, kann aber auch 16-bit sein (selten). + +**Konzept:** Feste Breite (fixed-width) vs. minimale Breite Typen. +
+ +### Frage 2.3 +**Welches Konzept beschreibt diese Python-Äquivalenz?** + +```c +// C +char name[50] = "Ada"; +``` + +```python +# Python +name = "Ada" # Unbegrenzte LĂ€nge! +``` + +- [ ] A) Statische vs. dynamische Typisierung +- [ ] B) Statische vs. dynamische Speicherallokation +- [ ] C) Kompiliert vs. interpretiert +- [ ] D) Pass-by-value vs. pass-by-reference + +
+Antwort + +**B)** C hat statische Allokation (feste GrĂ¶ĂŸe 50), Python dynamische (wĂ€chst mit Inhalt). + +**Konzept:** Arrays in C haben feste GrĂ¶ĂŸe, Strings in modernen Sprachen sind dynamisch. +
+ +--- + +## Modul 3: Flusskontrolle + +### Frage 3.1 +**Welche Struktur ist hier dargestellt?** + +``` +┌────────────┐ +│Bedingung? │ +└────────────┘ + │Ja + â–Œ +┌────────────┐ ┌────────────┐ +│Aktion A │───→│Bedingung? │ +└────────────┘ └────────────┘ + │Nein + â–Œ + ┌────────────┐ + │Aktion B │ + └────────────┘ +``` + +- [ ] A) If-Else +- [ ] B) For-Loop +- [ ] C) Nested If (verschachtelt) +- [ ] D) Switch-Case + +
+Antwort + +**C)** Nested If: Eine Aktion enthÀlt eine weitere Bedingung. + +**Konzept:** Verschachtelte Kontrollstrukturen (Nested Control Structures). +
+ +### Frage 3.2 +**Was ist die Ausgabe?** + +```c +for (int i = 0; i < 5; i++) { + if (i == 2) continue; + if (i == 4) break; + printf("%d ", i); +} +``` + +- [ ] A) `0 1 2 3` +- [ ] B) `0 1 3 4` +- [ ] C) `0 1 3` +- [ ] D) `0 1 2 3 4` + +
+Antwort + +**C)** `0 1 3` + +- i=0: print 0 +- i=1: print 1 +- i=2: continue (ĂŒberspringt print) +- i=3: print 3 +- i=4: break (Schleife beendet) + +**Konzept:** `continue` springt zum nĂ€chsten Iteration, `break` verlĂ€sst die Schleife. +
+ +### Frage 3.3 +**Universelles Konzept: Welche Sprache hat KEINE "for"-Schleife?** + +- [ ] A) Python +- [ ] B) C++ +- [ ] C) JavaScript +- [ ] D) Alle haben for-Schleifen + +
+Antwort + +**D)** Alle haben `for`-Schleifen (Syntax variiert): +- C/C++: `for (init; cond; step)` +- Python: `for item in iterable` +- JavaScript: `for (init; cond; step)` oder `for...of` + +**Konzept:** Die Idee der Wiederholung ist universell. +
+ +--- + +## Modul 4: Funktionen + +### Frage 4.1 +**Was ist der Unterschied zwischen Call-by-Value und Call-by-Reference?** + +- [ ] A) Value ist schneller, Reference langsamer +- [ ] B) Value kopiert Daten, Reference teilt Daten +- [ ] C) Value funktioniert nur mit primitiven Typen +- [ ] D) Kein Unterschied in C + +
+Antwort + +**B)** Call-by-Value kopiert den Wert (Änderungen beeinflussen Original nicht). Call-by-Reference teilt die Adresse (Änderungen beeinflussen Original). + +**Konzept:** ParameterĂŒbergabe-Semantik. +
+ +### Frage 4.2 +**Analyse:** + +```c +void swap(int a, int b) { + int temp = a; + a = b; + b = temp; +} + +int main() { + int x = 5, y = 10; + swap(x, y); + printf("%d %d", x, y); +} +``` + +**Ausgabe?** + +- [ ] A) `10 5` +- [ ] B) `5 10` +- [ ] C) `5 5` +- [ ] D) Undefiniert + +
+Antwort + +**B)** `5 10` – Die Werte werden nicht getauscht! + +C nutzt Call-by-Value. `swap` Ă€ndert nur Kopien von `x` und `y`. FĂŒr echtes Swapping brĂ€uchte man Pointer: `void swap(int* a, int* b)`. + +**Konzept:** C ist immer Call-by-Value (auch Pointer werden by value ĂŒbergeben – die Adresse wird kopiert). +
+ +### Frage 4.3 +**Rekursion: Was berechnet diese Funktion?** + +```c +int mystery(int n) { + if (n <= 1) return 1; + return n * mystery(n - 1); +} +``` + +- [ ] A) Summe 1 bis n +- [ ] B) FakultÀt (n!) +- [ ] C) Fibonacci +- [ ] D) 2^n + +
+Antwort + +**B)** FakultĂ€t: `n! = n × (n-1) × ... × 1` + +Beispiel: `mystery(5)` = 5 × 4 × 3 × 2 × 1 = 120 + +**Konzept:** Rekursion = Funktion ruft sich selbst mit einfacherem Problem. +
+ +--- + +## Modul 5: Datenstrukturen + +### Frage 5.1 +**Welche Datenstruktur ist fĂŒr "Wer war zuletzt hier?" am besten?** + +- [ ] A) Queue (FIFO) +- [ ] B) Stack (LIFO) +- [ ] C) Linked List +- [ ] D) Hash Map + +
+Antwort + +**B)** Stack (LIFO = Last In, First Out). Das letzte Element, das hinzugefĂŒgt wurde, wird als erstes zurĂŒckgegeben. + +**Konzept:** LIFO fĂŒr "Undo", "Back-Button", "Call Stack". +
+ +### Frage 5.2 +**ZeitkomplexitĂ€t: Wie lange dauert das Suchen in einem Array der GrĂ¶ĂŸe N?** + +- [ ] A) O(1) – konstant +- [ ] B) O(log N) – logarithmisch +- [ ] C) O(N) – linear +- [ ] D) O(NÂČ) – quadratisch + +
+Antwort + +**C)** O(N) – Im ungĂŒnstigsten Fall muss jedes Element geprĂŒft werden (lineare Suche). + +Mit sortiertem Array und binĂ€rer Suche: O(log N). + +**Konzept:** ZeitkomplexitĂ€t beschreibt Skalierung, nicht absolute Zeit. +
+ +### Frage 5.3 +**Was ist der Vorteil einer Linked List gegenĂŒber einem Array?** + +- [ ] A) Schnellerer Zugriff auf Elemente +- [ ] B) Weniger Speicherverbrauch +- [ ] C) EinfĂŒgen/Löschen ohne Verschieben +- [ ] D) Cache-Effizienz + +
+Antwort + +**C)** EinfĂŒgen/Löschen ist O(1) bei bekannter Position (nur Pointer Ă€ndern). Arrays mĂŒssen Elemente verschieben (O(N)). + +**Konzept:** Trade-offs: Arrays = schneller Zugriff, Lists = flexibles EinfĂŒgen. +
+ +--- + +## Modul 6: Pointer + +### Frage 6.1 +**Was ist der Output?** + +```c +int a = 10; +int *p = &a; +int **pp = &p; + +printf("%d", **pp); +``` + +- [ ] A) Adresse von a +- [ ] B) Adresse von p +- [ ] C) 10 +- [ ] D) Compiler-Fehler + +
+Antwort + +**C)** 10 + +- `pp` ist Pointer zu Pointer +- `*pp` = `p` = Adresse von `a` +- `**pp` = `*p` = Wert von `a` = 10 + +**Konzept:** Mehrfache Dereferenzierung (Pointer Chains). +
+ +### Frage 6.2 +**Was ist ein "Dangling Pointer"?** + +- [ ] A) Ein Pointer auf NULL +- [ ] B) Ein Pointer auf freigegebenen Speicher +- [ ] C) Ein Pointer auf Stack-Speicher +- [ ] D) Ein uninitialisierter Pointer + +
+Antwort + +**B)** Dangling Pointer zeigt auf Speicher, der bereits `free()`'d wurde (oder Stack-Variable außerhalb ihres Scopes). + +**Beispiel:** +```c +int* bad() { + int x = 10; + return &x; // Dangling nach return! +} +``` + +**Konzept:** Lebensdauer des Pointers ≠ Lebensdauer des Ziels. +
+ +### Frage 6.3 +**Array-Pointer-Äquivalenz:** + +```c +int arr[5] = {10, 20, 30, 40, 50}; +int *p = arr; +``` + +**Welche Expression ist NICHT Ă€quivalent?** + +- [ ] A) `arr[2]` und `*(arr + 2)` +- [ ] B) `p[2]` und `*(p + 2)` +- [ ] C) `&arr[2]` und `p + 2` +- [ ] D) `sizeof(arr)` und `sizeof(p)` + +
+Antwort + +**D)** `sizeof(arr)` = 20 (5 ints × 4 bytes), `sizeof(p)` = 8 (Pointer-GrĂ¶ĂŸe auf 64-bit System). + +Alle anderen sind Pointer-Arithmetik-Äquivalenzen. + +**Konzept:** Arrays und Pointer sind verwandt, aber nicht identisch! +
+ +--- + +## Modul 7: OOP + +### Frage 7.1 +**Was beschreibt "Ein Hund IST EIN Tier"?** + +- [ ] A) Kapselung +- [ ] B) Vererbung +- [ ] C) Polymorphie +- [ ] D) Abstraktion + +
+Antwort + +**B)** Vererbung (Inheritance): `class Dog : public Animal` + +"IS-A"-Beziehung = Vererbung +"HAS-A"-Beziehung = Komposition + +**Konzept:** Vererbung modelliert Taxonomien (Kategorien). +
+ +### Frage 7.2 +**Was ist der Unterschied zwischen `virtual` und `override`?** + +- [ ] A) `virtual` in Basisklasse, `override` in abgeleiteter Klasse +- [ ] B) `virtual` fĂŒr Variablen, `override` fĂŒr Funktionen +- [ ] C) Beide sind identisch +- [ ] D) `override` ist C-only + +
+Antwort + +**A)** +- `virtual` in **Basisklasse** markiert ĂŒberschreibbare Methode +- `override` in **abgeleiteter Klasse** dokumentiert Überschreibung (Compiler prĂŒft!) + +```cpp +class Animal { + virtual void speak(); // Kann ĂŒberschrieben werden +}; + +class Dog : public Animal { + void speak() override; // Überschreibt explizit +}; +``` + +**Konzept:** `override` ist optional aber empfohlen (Compiler-Hilfe). +
+ +### Frage 7.3 +**In welcher Sprache ist alles ein Objekt?** + +- [ ] A) C +- [ ] B) C++ +- [ ] C) Python +- [ ] D) Keine der genannten + +
+Antwort + +**C)** Python – Alles (Zahlen, Strings, Funktionen, Module) ist ein Objekt mit Methoden und Attributen. + +C hat keine Objekte, C++ hat primitive Typen (int, float) ohne Methoden. + +**Konzept:** "Alles ist ein Objekt" = Uniforme Behandlung aller Daten. +
+ +--- + +## Modul 8: Modularisierung + +### Frage 8.1 +**Was beschreibt das Singleton Pattern?** + +- [ ] A) Viele Instanzen einer Klasse +- [ ] B) Genau eine Instanz einer Klasse +- [ ] C) Keine Instanzen erlaubt +- [ ] D) Automatische Instanzerstellung + +
+Antwort + +**B)** Singleton = Genau eine Instanz (z.B. Datenbank-Verbindung, Logger). + +**Konzept:** Globale Zustandskontrolle mit gekapseltem Zugriff. +
+ +### Frage 8.2 +**Was ist "Separation of Concerns"?** + +- [ ] A) Alle Code in einer Datei +- [ ] B) Verschiedene Aspekte in verschiedene Module +- [ ] C] Keine AbhÀngigkeiten zwischen Modulen +- [ ] D) Ein Modul pro Funktion + +
+Antwort + +**B)** Separation of Concerns = UI, Logik, Daten getrennt halten. + +Beispiel: MVC Pattern (Model-View-Controller) + +**Konzept:** Änderungen in einem Bereich beeinflussen andere nicht. +
+ +### Frage 8.3 +**Welches Design Pattern passt?** + +**Problem:** Verschiedene Zahlungsmethoden (Kreditkarte, PayPal, Crypto) sollen austauschbar sein. + +- [ ] A) Singleton +- [ ] B) Factory +- [ ] C) Strategy +- [ ] D) Observer + +
+Antwort + +**C)** Strategy Pattern = Austauschbare Algorithmen/Strategien. + +```cpp +class PaymentStrategy { + virtual void pay(amount) = 0; +}; + +class CreditCard : public PaymentStrategy { ... }; +class PayPal : public PaymentStrategy { ... }; +``` + +**Konzept:** Strategy = Familie von Algorithmen, austauschbar zur Laufzeit. +
+ +--- + +## 🎯 Final-Quiz: Mixed + +### F1. Welche Konzepte sind sprachunabhĂ€ngig? + +- [ ] A) `malloc` und `free` +- [ ] B) Stack und Heap +- [ ] C) `class` und `struct` +- [ ] D) `int` und `float` + +
+Antwort + +**B)** Stack und Heap sind Speicherkonzepte, die in jeder Sprache existieren (auch wenn sie unterschiedlich verwaltet werden). + +A) Nur C/C++ +C) Nicht in C +D) Konzept existiert, aber Namen variieren +
+ +### F2. Was ist der Output? + +```c +int arr[] = {1, 2, 3}; +int *p = arr; +p++; +printf("%d", *p); +``` + +- [ ] A) 1 +- [ ] B) 2 +- [ ] C) 3 +- [ ] D) Adresse von arr[1] + +
+Antwort + +**B)** 2 + +- `p` zeigt auf `arr[0]` +- `p++` verschiebt um sizeof(int) → zeigt auf `arr[1]` +- `*p` = 2 +
+ +### F3. Was ist ein "Memory Leak"? + +- [ ] A) Zugriff auf ungĂŒltigen Speicher +- [ ] B) Nicht freigegebener Heap-Speicher +- [ ] C) Stack Overflow +- [ ] D) Zu große Variable + +
+Antwort + +**B)** Memory Leak = `malloc()` ohne `free()` → Speicher bleibt belegt bis Programmende. + +```c +while (1) { + malloc(1000); // Leak! Nie freigegeben. +} +``` +
+ +### F4. Welche OOP-Sprache hat kein multiple inheritance? + +- [ ] A) C++ +- [ ] B) Python +- [ ] C) Java +- [ ] D) Ruby + +
+Antwort + +**C)** Java erlaubt nur single inheritance fĂŒr Klassen (Interfaces können mehrfach implementiert werden). + +C++ und Python erlauben multiple inheritance: `class X : public A, public B`. + +**Konzept:** Multiple Inheritance kann zu Diamant-Problem fĂŒhren. +
+ +--- + +## ✅ Ergebnis-Tabelle + +| Modul | Fragen | Bestanden? | +|-------|--------|------------| +| 1: Memory | 3/3 | ⬜ | +| 2: Datentypen | 3/3 | ⬜ | +| 3: Flusskontrolle | 3/3 | ⬜ | +| 4: Funktionen | 3/3 | ⬜ | +| 5: Datenstrukturen | 3/3 | ⬜ | +| 6: Pointer | 3/3 | ⬜ | +| 7: OOP | 3/3 | ⬜ | +| 8: Modularisierung | 3/3 | ⬜ | +| **Final** | **4/4** | ⬜ | + +**Score:** ___ / 28 + +| Bewertung | Score | +|-----------|-------| +| 🏆 Meister | 26-28 | +| ⭐ Experte | 22-25 | +| ✅ Gut | 18-21 | +| 📚 Nacharbeiten | < 18 | + +--- + +*Viel Erfolg beim Test!*