malloc gibt dir Speicher zur Laufzeit – so viel wie du brauchst! Aber du bist selbst verantwortlich: jedes malloc braucht genau ein free, sonst gibt es einen Memory Leak!
malloc und free
#include <stdlib.h> int n = 10; int *arr = (int*)malloc(n * sizeof(int)); if (arr == NULL) { printf("Fehler!\n"); return 1; } /* ... Array benutzen ... */ free(arr); // Speicher freigeben!
| Funktion | Zweck |
|---|---|
| malloc(n) | n Bytes anfordern |
| calloc(n, s) | n×s Bytes, mit 0 initialisiert |
| free(p) | Speicher freigeben |
| sizeof(int) | Größe des Typs in Bytes |
⚠️ Jedes malloc braucht ein free!
Vergisst du free(), entsteht ein Memory Leak – Speicher bleibt belegt. Immer NULL-Check nach malloc!
Stack vs. Heap
In C gibt es zwei grundlegende Speicherbereiche. Lokale Variablen leben auf dem Stack – der Heap ist für dynamisch allokierten Speicher via malloc.
| Stack | Heap | |
|---|---|---|
| Verwaltung | Automatisch | Manuell (malloc/free) |
| Größe | Begrenzt (~1–8 MB) | Nur durch RAM begrenzt |
| Geschwindigkeit | Sehr schnell | Etwas langsamer |
| Lebensdauer | Bis Funktion endet | Bis free() aufgerufen wird |
| Typisch für | Lokale Variablen, Arrays (bekannte Größe) | Große Arrays, Größe erst zur Laufzeit bekannt |
Wann Heap benutzen?
Wenn die Größe des Arrays erst zur Laufzeit bekannt ist (z.B. der Benutzer gibt die Anzahl ein), oder wenn die Daten eine Funktion überleben müssen, ist der Heap die richtige Wahl.
malloc, calloc, realloc
Die Standardbibliothek <stdlib.h> bietet drei Allokations-Funktionen mit unterschiedlichem Verhalten:
| Funktion | Zweck | Initialisiert? |
|---|---|---|
| malloc(n) | n Bytes allokieren | Nein (Garbage Values!) |
| calloc(n, size) | n Elemente × size Bytes, alle auf 0 | Ja (0) |
| realloc(ptr, n) | Bestehenden Block auf n Bytes ändern | Neue Bytes nicht init. |
| free(ptr) | Speicher freigeben | — |
malloc liefert uninitialisierte Daten!
Nach malloc enthalten die Bytes zufälligen Inhalt ("Garbage"). Verwende calloc wenn du sicher mit 0 starten willst, oder initialisiere jeden Wert manuell.
Memory Leak – der stille Fehler
Ein Memory Leak entsteht wenn allokierter Speicher nie mit free() freigegeben wird. Das Programm läuft weiter, belegt aber immer mehr RAM – bei Serverprogrammen oder lang laufenden Prozessen kann das zum Absturz führen.
void leak() { int *arr = (int*) malloc(10 * sizeof(int)); // free(arr) vergessen! return; // Speicher bleibt belegt – Memory Leak! }
Memory Leaks erkennen
Das Programm läuft scheinbar normal, aber belegt immer mehr RAM. Bei Serverprogrammen oder lang laufenden Prozessen kritisch – das System wird mit der Zeit langsamer und stürzt schließlich ab. Tools wie Valgrind helfen Memory Leaks zu finden.
Häufige Fehler
| Fehler | Folge | Lösung |
|---|---|---|
| NULL-Check vergessen | Crash bei Speichermangel | Immer if (ptr == NULL) nach malloc |
| free() zweimal | Double free → Crash / Undefined Behavior | Nach free: ptr = NULL; |
| Use-after-free | Undefined Behavior, Datenverfälschung | Pointer nach free auf NULL setzen |
| Größe falsch | Zu wenig Speicher allokiert | Immer n * sizeof(Typ) verwenden |
Goldene Regel: jedes malloc hat genau ein free
Nach free(ptr) immer ptr = NULL; setzen. So wird ein versehentlicher zweiter free()-Aufruf harmlos (free(NULL) tut nichts) und ein Zugriff über den Pointer ist sofort als Bug erkennbar.
⚡ Code-Simulator
Teste den Code direkt im Browser – printf-Ausgaben werden simuliert:
Experimentiere mit dem Code – das ist der beste Weg um Pointer und structs wirklich zu verstehen!
🎯 Wissens-Quiz
📋 Spickzettel
✅ Checkliste Unit 28
- Ich kann malloc und free korrekt verwenden
- Ich führe nach malloc immer einen NULL-Check durch
- Ich verstehe den Unterschied zwischen Stack und Heap
- Ich vermeide Memory Leaks durch konsequentes free