programming-concepts-universal/docs/quiz-fragen.md

# 📝 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!*