C Academy · leksjon

malloc og free

Alloker på heapen

Leksjon 1 av 413 trinn

malloc og free er en gratis leksjon i C Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C Academy inneholder totalt 4 leksjoner.

Heapen

Så langt har variabler ligget på stakken med en fast levetid. Heapen gjør det mulig å be om minne under kjøring og beholde det så lenge det trengs.

Heap-minne håndteres manuelt ved hjelp av funksjoner i <stdlib.h>.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Kalle malloc

malloc(size) reserverer size byte og returnerer en peker til dem, eller NULL ved feil.

Minneområdet er uinitalisert: innholdet er ubestemt.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    printf("value = %d\n", *p);
    free(p);
    return 0;
}

Angi størrelse med sizeof

Angi alltid størrelsen på allokeringer med sizeof, slik at koden fungerer korrekt på alle plattformer.

Ved å skrive sizeof(*p) knyttes størrelsen automatisk til pekerens type.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    double *p = malloc(sizeof(*p));
    *p = 3.14;
    printf("%f\n", *p);
    free(p);
    return 0;
}

Kontroller alltid NULL

Hvis allokeringen mislykkes, returnerer malloc NULL. Dereferering av denne krasjer programmet.

Kontroller resultatet før det brukes.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        printf("allocation failed\n");
        return 1;
    }
    *p = 5;
    printf("ok: %d\n", *p);
    free(p);
    return 0;
}

Allokere en tabell

For å lagre mange elementer multipliserer man elementstørrelsen med antallet.

malloc(n * sizeof(int)) oppretter plass til n heltall.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Heap-tabeller bruker pekerindeksering

En heap-tabell aksesseres gjennom pekeren med den velkjente syntaksen arr[i], som er det samme som *(arr + i).

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Frigjøre minne

free(p) returnerer blokken til allokatoren. Etter dette må p ikke brukes til å aksessere minnet.

Hver vellykkede malloc trenger en tilsvarende free.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) er trygt

Det gjør ingenting å kalle free på en NULL-peker, og det er helt lovlig.

Dette forenkler oppryddingskode som kan kjøres før allokeringen lykkes.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Returnere heap-minne

I motsetning til stakkvariabler overlever heap-minne etter at funksjonen returnerer. Dermed kan en funksjon allokere og returnere en buffer.

#include <stdio.h>
#include <stdlib.h>

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

Ikke cast malloc i C

I C returnerer malloc en void * som automatisk konverteres til enhver pekertype.

Det er unødvendig å caste verdien, og det kan skjule en manglende <stdlib.h>-inkludering.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

Ikke frigjøre to ganger

Å kalle free på den samme pekeren to ganger er udefinert oppførsel og kan ødelegge heapen.

Sett pekeren til NULL etter frigjøring, slik at utilsiktet gjenbruk blir ufarlig.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Hurtigsjekk

Test kunnskapene om malloc og free.

Besvar den i den interaktive leksjonen

Oppsummering

De har lært det grunnleggende om heap-allokering:

malloc(size) reserverer uinitialiserte byte og returnerer NULL ved feil.
Kontroller alltid resultatet, og angi størrelsen med sizeof.
free(p) returnerer minnet; hver malloc trenger én free.
free(NULL) er trygt; dobbel frigjøring er udefinert.

Gratis å komme i gang

Lær deg C med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 144

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «malloc og free» gratis?

Ja – hele teksten i «malloc og free» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «malloc og free»?

Alloker på heapen Du øver på C Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C Academy?

Ingen tidligere erfaring er nødvendig. C Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «malloc og free»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C Academy-leksjonen?

Ja. Alle C Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til C Academy