C Academy · Lezione

malloc e free

Allocare nell'heap

malloc e free è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Lo heap

Finora le variabili vivevano nello stack, con una durata fissa. Lo heap consente di richiedere memoria durante l'esecuzione e conservarla per tutto il tempo necessario.

La memoria dello heap viene gestita manualmente utilizzando le funzioni di <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;
}

Chiamare malloc

malloc(size) riserva size byte e restituisce un puntatore a tale area, oppure NULL in caso di errore.

La memoria è non inizializzata: il suo contenuto è indeterminato.

#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;
}

Determinare la dimensione con sizeof

Determini sempre la dimensione delle allocazioni con sizeof, affinché il codice funzioni correttamente su qualsiasi piattaforma.

Scrivere sizeof(*p) collega automaticamente la dimensione al tipo del puntatore.

#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;
}

Controllare sempre NULL

Se l'allocazione non riesce, malloc restituisce NULL. Dereferenziarlo causa il crash del programma.

Controlli il risultato prima di utilizzarlo.

#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;
}

Allocare un array

Per contenere molti elementi, moltiplichi la dimensione dell'elemento per il numero di elementi.

malloc(n * sizeof(int)) crea spazio per n interi.

#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;
}

Gli array nello heap usano l'indicizzazione tramite puntatore

Si accede a un array nello heap tramite il relativo puntatore, usando la familiare sintassi arr[i], equivalente a *(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;
}

Liberare la memoria

free(p) restituisce il blocco all'allocatore. Dopodiché non deve più utilizzare p per accedere a quella memoria.

Ogni malloc completato con successo richiede un free corrispondente.

#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) è sicuro

Chiamare free su un puntatore NULL non esegue alcuna operazione ed è perfettamente legale.

Questo semplifica il codice di pulizia che può essere eseguito prima che l'allocazione abbia successo.

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

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

Restituire memoria dello heap

A differenza delle variabili dello stack, la memoria dello heap sopravvive al ritorno dalla funzione. Questo consente a una funzione di allocare e restituire un 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;
}

Non convertire malloc in C

In C, malloc restituisce un void * che viene convertito automaticamente in qualsiasi tipo di puntatore.

La conversione esplicita non è necessaria e può nascondere l'assenza dell'inclusione di <stdlib.h>.

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

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

Non eseguire free due volte

Chiamare free due volte sullo stesso puntatore produce comportamento indefinito e può corrompere lo heap.

Imposti il puntatore su NULL dopo aver liberato la memoria, così da rendere innocuo un riutilizzo accidentale.

#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;
}

Verifica rapida

Verifichi la Sua conoscenza di malloc e free.

Riepilogo

Ha appreso le basi dell'allocazione nello heap:

malloc(size) riserva byte non inizializzati e restituisce NULL in caso di errore.
Controlli sempre il risultato e determini la dimensione con sizeof.
free(p) restituisce la memoria; ogni malloc richiede un free.
free(NULL) è sicuro; il double free produce comportamento indefinito.

Domande Frequenti

La lezione «malloc e free» è gratuita?

Sì — il testo completo di «malloc e free» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «malloc e free»?

Allocare nell'heap Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «malloc e free»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C Academy