Add quiz-fragen.md
This commit is contained in:
679
docs/quiz-fragen.md
Normal file
679
docs/quiz-fragen.md
Normal file
@@ -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!*
|
||||
Reference in New Issue
Block a user