Memory Leaks
Leaks finden und vermeiden
Memory Leaks ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Speicherverlust
Ein Speicherverlust tritt auf, wenn Sie Heap-Speicher reservieren, ihn aber nie freigeben und den einzigen Zeiger darauf verlieren.
Der Speicher bleibt bis zum Ende des Programms reserviert und verschwendet Ressourcen.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
*p = 5;
printf("%d\n", *p);
free(p);
return 0;
}Den Zeiger verlieren
Der klassische Speicherverlust entsteht, wenn ein Zeiger vor der Freigabe der alten Speicherreservierung mit einer neuen überschrieben wird.
Der erste Block wird dadurch unerreichbar.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
free(p);
p = malloc(sizeof(int));
*p = 10;
printf("%d\n", *p);
free(p);
return 0;
}Speicherverluste in Schleifen
Wenn Sie innerhalb einer Schleife reservieren, ohne in jeder Iteration freizugeben, wächst der Speicherverlust schnell.
Geben Sie den Speicher vor der nächsten Iteration frei, bevor diese den Zeiger überschreibt.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
for (int i = 0; i < 3; i++) {
int *p = malloc(sizeof(int));
*p = i;
printf("%d ", *p);
free(p);
}
printf("\n");
return 0;
}Frühe Rückgaben verursachen Speicherverluste
Ein frühes return nach einer Speicherreservierung kann die Bereinigung überspringen. Geben Sie den Speicher auf jedem Rückgabepfad frei.
#include <stdio.h>
#include <stdlib.h>
int process(int bad) {
int *p = malloc(sizeof(int));
if (bad) {
free(p);
return -1;
}
*p = 42;
int r = *p;
free(p);
return r;
}
int main(void) {
printf("%d\n", process(0));
return 0;
}Das goto-Bereinigungsmuster
Ein einziges Bereinigungslabel, das mit goto erreicht wird, stellt sicher, dass alles an einer Stelle freigegeben wird, und vermeidet doppelte Aufrufe von free.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int rc = 1;
int *p = malloc(sizeof(int));
if (!p) goto done;
*p = 7;
printf("%d\n", *p);
rc = 0;
done:
free(p);
return rc;
}Jede Reservierung zuordnen
Die einfachste Regel lautet: Für jeden Aufruf von malloc, calloc oder realloc muss es genau einen entsprechenden Aufruf von free geben.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
char *a = malloc(8);
char *b = calloc(4, sizeof(char));
a[0] = 'x';
printf("%c %d\n", a[0], b[0]);
free(a);
free(b);
return 0;
}Verschachtelte Reservierungen freigeben
Wenn eine Struktur Heap-Speicher besitzt, geben Sie zuerst die inneren Zeiger und anschließend den äußeren Block frei.
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *data;
} Box;
int main(void) {
Box *b = malloc(sizeof(Box));
b->data = malloc(3 * sizeof(int));
b->data[0] = 1;
printf("%d\n", b->data[0]);
free(b->data);
free(b);
return 0;
}Ein Zeiger-Array freigeben
Wenn Sie ein Array von Zeigern reservieren und jeder Eintrag eine eigene Reservierung ist, geben Sie zuerst alle Einträge und danach das Array frei.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int **rows = malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
rows[i] = malloc(2 * sizeof(int));
rows[i][0] = i;
}
for (int i = 0; i < n; i++) free(rows[i]);
free(rows);
printf("freed all rows\n");
return 0;
}Besitzverhältnisse festlegen
Legen Sie fest, wer jede Reservierung besitzt und für ihre Freigabe verantwortlich ist. Dokumentieren Sie dies, damit Aufrufer wissen, ob sie einen zurückgegebenen Zeiger freigeben müssen.
#include <stdio.h>
#include <stdlib.h>
char *make_greeting(void) {
char *s = malloc(6);
s[0]='h'; s[1]='i'; s[2]='\0';
return s;
}
int main(void) {
char *g = make_greeting();
printf("%s\n", g);
free(g);
return 0;
}Werkzeuge zum Finden von Speicherverlusten
Werkzeuge wie Valgrind und AddressSanitizer melden Speicherverluste, indem sie jede Reservierung verfolgen und anzeigen, welche nie freigegeben wurden.
Sie sind unverzichtbar, um reale Programme zu überprüfen.
Ein sauberer Lebenszyklus für Reservierungen
Zusammengefasst: reservieren, prüfen, verwenden, auf jedem Pfad freigeben und den Zeiger auf null setzen. So bleiben Programme frei von Speicherverlusten.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(4 * sizeof(int));
if (!p) return 1;
for (int i = 0; i < 4; i++) p[i] = i + 1;
int sum = 0;
for (int i = 0; i < 4; i++) sum += p[i];
printf("sum = %d\n", sum);
free(p);
p = NULL;
return 0;
}Kurzer Test
Testen Sie Ihr Verständnis von Speicherverlusten.
Zusammenfassung
Sie haben gelernt, Speicherverluste zu vermeiden:
- Ordnen Sie jeder Reservierung genau einen Aufruf von
freezu. - Geben Sie den Speicher auf jedem Rückgabepfad frei, auch bei frühen Rückgaben und Fehlern.
- Geben Sie verschachtelte Reservierungen und Reservierungen in Zeiger-Arrays von innen nach außen frei.
- Definieren Sie klare Besitzverhältnisse und verwenden Sie Werkzeuge wie Valgrind zur Überprüfung.
Häufig gestellte Fragen
Ist die Lektion „Memory Leaks“ kostenlos?
Ja — der vollständige Text von „Memory Leaks“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Memory Leaks“?
Leaks finden und vermeiden Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C Academy zu starten?
Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Memory Leaks“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?
Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.