Frigör minne och undvik läckor
Städa upp korrekt.
Frigör minne och undvik läckor är en gratis lektion i C Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C Academy innehåller totalt 4 lektioner.
Varje malloc behöver en free
Heap-minne förblir reserverat tills Ni frigör det med free. Om Ni tappar bort den enda pekaren till ett block utan att frigöra det läcker minnet.
Läckor byggs på med tiden och kan tömma minnet i långkörande program.
int *a = malloc(100 * sizeof(*a));
/* ... use a ... */
free(a);Vad free faktiskt gör
free(p) lämnar tillbaka blocket till allokeraren så att det kan återanvändas. Funktionen ändrar inte värdet på p i sig.
Efter free pekar p fortfarande på den gamla adressen, som nu är ogiltig. Att använda den leder till odefinierat beteende.
free(p);
/* p is now a dangling pointer */Fällan med hängande pekare
Att använda en pekare efter att den har frigjorts är ett use-after-free-fel. Det kan verka fungera, för att sedan korrumpera data eller krascha oförutsägbart.
Ett enkelt skydd är att sätta pekaren till NULL direkt efter frigöringen.
free(a);
a = NULL; /* now misuse is a clean NULL deref, easier to catch */Double free är odefinierat
Att anropa free två gånger på samma block korrumperar allokerarens interna tillstånd och leder ofta till en krasch.
Att sätta pekaren till NULL efter den första frigöringen hjälper, eftersom free(NULL) uttryckligen är säkert och inte gör någonting.
free(a);
a = NULL;
free(a); /* free(NULL) is a harmless no-op */Frigör bara det Ni har malloc:at
Skicka endast en pekare som kommer från malloc, calloc eller realloc till free.
Att frigöra adressen till en stackvariabel, en strängliteral eller en pekare till mitten av ett block leder till odefinierat beteende.
int x = 5;
/* free(&x); WRONG: x is on the stack */
int *p = malloc(sizeof(int));
free(p); /* correct */Läcka vid en tidig retur
En vanlig läcka uppstår när Ni allokerar minne och sedan når en felhanteringsväg som returnerar innan minnet frigörs. Blocket går då förlorat.
Se till att varje avslutningsväg som äger minnet frigör det först.
int *a = malloc(n * sizeof(*a));
if (something_failed) {
free(a); /* don't forget this before returning */
return -1;
}Ett rent program för allokering och frigöring
Detta program allokerar, använder och frigör minne på alla vägar utan att läcka något.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 4;
int *a = malloc(n * sizeof(*a));
if (!a) return 1;
for (int i = 0; i < n; i++) a[i] = i + 1;
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
printf("%d\n", sum);
free(a);
a = NULL;
return 0;
}Frigöra nästlade allokeringar
Om ett block innehåller pekare till andra block ska de inre blocken frigöras först och det yttre blocket därefter.
Om det yttre blocket frigörs först går adresserna till de inre blocken förlorade, vilket gör att de läcker.
for (size_t i = 0; i < rows; i++)
free(grid[i]); /* free each row first */
free(grid); /* then the array of pointers */En ägare per block
Bestäm vilken del av koden som äger varje allokering och ansvarar för att frigöra den.
Om två pekare refererar till samma block och båda frigör det uppstår en double free. Tydligt ägarskap förhindrar detta.
Upptäcka läckor med verktyg
Ni behöver inte hitta läckor med blotta ögat. Verktyg som valgrind eller AddressSanitizer rapporterar läckor och ogiltiga frigöringar med radnummer.
Kompilera med -g och kör programmet under verktyget för att se exakt vad som inte frigjordes.
/* gcc -g -fsanitize=address prog.c && ./a.out */
/* or: valgrind --leak-check=full ./a.out */Frigör i omvänd ordning mot initieringen
En tillförlitlig vana är att frigöra resurser i omvänd ordning mot den ordning i vilken Ni anskaffade dem.
Det återspeglar hur beroendena byggdes upp och gör rensningen förutsägbar.
char *buf = malloc(64);
int *idx = malloc(64 * sizeof(int));
/* ... use them ... */
free(idx); /* free last-acquired first */
free(buf);Snabbkontroll
Testa Er förståelse av att frigöra minne.
Sammanfattning
Koppla varje allokering till exakt en free på varje kodväg.
Undvik hängande pekare och double free genom att sätta pekare till NULL efter frigöringen. Frigör nästlade allokeringar inifrån och ut, ge varje block en ägare och använd valgrind eller ASan för att upptäcka läckor. Nu har Ni alla verktyg som behövs för dynamiska arrayer.
Lär dig C med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Frigör minne och undvik läckor” gratis?
Ja – hela texten till ”Frigör minne och undvik läckor” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Frigör minne och undvik läckor”?
Städa upp korrekt. Ni övar på C Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig C Academy?
Du behöver inga förkunskaper. Utbildningen i C Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Frigör minne och undvik läckor”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här C Academy-lektionen?
Ja. Varje C Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Allokera en array
- Utöka med realloc
- En återanvändbar vektortyp
- Frigör minne och undvik läckor