Add quiz-fragen.md

2026-04-15 00:10:54 +02:00
parent 73b2c95afd
commit 44ecca0936
1 changed files with 679 additions and 0 deletions
--- a/docs/quiz-fragen.md
+++ 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`
 <details>
 <summary>Antwort</summary>
 **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).
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **B)** Stack = Automatisch verwaltet (B), Heap = Manuell verwaltet (A)
 **Konzept:** Stack (automatisch, schnell, begrenzt) vs Heap (manuell/verwaltet, flexibel, langsam).
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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)
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **C)** `int8_t` (aus `<stdint.h>`) 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.
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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
 <details>
 <summary>Antwort</summary>
 **C)** Nested If: Eine Aktion enthält eine weitere Bedingung.
 **Konzept:** Verschachtelte Kontrollstrukturen (Nested Control Structures).
 </details>
 ### 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`
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ### Frage 3.3
 **Universelles Konzept: Welche Sprache hat KEINE "for"-Schleife?**
 - [ ] A) Python
 - [ ] B) C++
 - [ ] C) JavaScript
 - [ ] D) Alle haben for-Schleifen
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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
 <details>
 <summary>Antwort</summary>
 **B)** Call-by-Value kopiert den Wert (Änderungen beeinflussen Original nicht). Call-by-Reference teilt die Adresse (Änderungen beeinflussen Original).
 **Konzept:** Parameterübergabe-Semantik.
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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).
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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
 <details>
 <summary>Antwort</summary>
 **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".
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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
 <details>
 <summary>Antwort</summary>
 **C)** 10
 - `pp` ist Pointer zu Pointer
 - `*pp` = `p` = Adresse von `a`
 - `**pp` = `*p` = Wert von `a` = 10
 **Konzept:** Mehrfache Dereferenzierung (Pointer Chains).
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ### 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)`
 <details>
 <summary>Antwort</summary>
 **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!
 </details>
 ---
 ## Modul 7: OOP
 ### Frage 7.1
 **Was beschreibt "Ein Hund IST EIN Tier"?**
 - [ ] A) Kapselung
 - [ ] B) Vererbung
 - [ ] C) Polymorphie
 - [ ] D) Abstraktion
 <details>
 <summary>Antwort</summary>
 **B)** Vererbung (Inheritance): `class Dog : public Animal`
 "IS-A"-Beziehung = Vererbung  
 "HAS-A"-Beziehung = Komposition
 **Konzept:** Vererbung modelliert Taxonomien (Kategorien).
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **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).
 </details>
 ### Frage 7.3
 **In welcher Sprache ist alles ein Objekt?**
 - [ ] A) C
 - [ ] B) C++
 - [ ] C) Python
 - [ ] D) Keine der genannten
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 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
 <details>
 <summary>Antwort</summary>
 **B)** Singleton = Genau eine Instanz (z.B. Datenbank-Verbindung, Logger).
 **Konzept:** Globale Zustandskontrolle mit gekapseltem Zugriff.
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **B)** Separation of Concerns = UI, Logik, Daten getrennt halten.
 Beispiel: MVC Pattern (Model-View-Controller)
 **Konzept:** Änderungen in einem Bereich beeinflussen andere nicht.
 </details>
 ### Frage 8.3
 **Welches Design Pattern passt?**
 **Problem:** Verschiedene Zahlungsmethoden (Kreditkarte, PayPal, Crypto) sollen austauschbar sein.
 - [ ] A) Singleton
 - [ ] B) Factory
 - [ ] C) Strategy
 - [ ] D) Observer
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## 🎯 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`
 <details>
 <summary>Antwort</summary>
 **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
 </details>
 ### 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]
 <details>
 <summary>Antwort</summary>
 **B)** 2
 - `p` zeigt auf `arr[0]`
 - `p++` verschiebt um sizeof(int) → zeigt auf `arr[1]`
 - `*p` = 2
 </details>
 ### 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
 <details>
 <summary>Antwort</summary>
 **B)** Memory Leak = `malloc()` ohne `free()` → Speicher bleibt belegt bis Programmende.
 ```c
 while (1) {
    malloc(1000);  // Leak! Nie freigegeben.
 }
 ```
 </details>
 ### F4. Welche OOP-Sprache hat kein multiple inheritance?
 - [ ] A) C++
 - [ ] B) Python
 - [ ] C) Java
 - [ ] D) Ruby
 <details>
 <summary>Antwort</summary>
 **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.
 </details>
 ---
 ## ✅ 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!*