C++ Academy · Lezione

Allocazione nell'heap con new/delete

Gestire la memoria dinamica

Allocazione nell'heap con new/delete è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Memoria dinamica con new

L'operatore new alloca un oggetto nell'heap (free store) e restituisce un puntatore a tale oggetto. Gli oggetti nell'heap rimangono in memoria finché non li libera esplicitamente.

#include <iostream>

int main() {
    int* p = new int(42);   // heap allocation
    std::cout << *p << "\n";
    delete p;               // release it
}

Rilascio con delete

Ogni new deve essere associato a esattamente un delete. Dimenticarlo causa una perdita di memoria; eseguirlo due volte corrompe l'heap.

#include <iostream>

int main() {
    double* d = new double(3.5);
    std::cout << *d << "\n";
    delete d;     // exactly once
}

Array: new[] e delete[]

Per gli array usi new[] e il corrispondente delete[]. Abbinare new[] al semplice delete produce un comportamento indefinito.

#include <iostream>

int main() {
    int* arr = new int[3]{1, 2, 3};
    for (int i = 0; i < 3; ++i) std::cout << arr[i] << "\n";
    delete[] arr;   // note the [ ]
}

Perché usare l'heap?

Usi l'heap quando un oggetto deve sopravvivere alla funzione che lo ha creato o quando la sua dimensione è nota solo a runtime. In caso contrario, preferisca lo stack.

La durata nell'heap è manuale

A differenza dello stack, l'heap non libera automaticamente gli oggetti. È lei a controllare esattamente quando viene rilasciata la memoria e ne è responsabile.

#include <iostream>

int* makeCounter() {
    return new int(0);   // survives the function
}

int main() {
    int* c = makeCounter();
    std::cout << *c << "\n";
    delete c;
}

Impostare i puntatori a nullptr dopo delete

Dopo aver eliminato l'oggetto, imposti il puntatore a nullptr, così un riutilizzo accidentale genera un errore evidente invece di accedere alla memoria liberata.

#include <iostream>

int main() {
    int* p = new int(9);
    delete p;
    p = nullptr;     // now p is safe to check
    if (!p) std::cout << "freed\n";
}

L'allocazione può fallire

Se il sistema esaurisce la memoria, new genera std::bad_alloc. Per allocazioni molto grandi, è una possibilità concreta.

Buffer di dimensione determinata a runtime

Gli array nell'heap possono usare una dimensione calcolata a runtime, cosa che gli array nello stack non possono fare in modo portabile.

#include <iostream>

int main() {
    int n = 5;
    int* buf = new int[n];
    for (int i = 0; i < n; ++i) buf[i] = i * i;
    std::cout << buf[4] << "\n";
    delete[] buf;
}

Preferire i puntatori smart

Il C++ moderno evita new/delete grezzi. std::unique_ptr e std::make_unique liberano automaticamente la memoria quando il puntatore esce dall'ambito.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(42);
    std::cout << *p << "\n";
}   // freed automatically

Il costo dell'heap

L'allocazione nell'heap è più lenta di quella nello stack: cerca un blocco libero e aggiorna le strutture di gestione. Molte allocazioni piccole e frequenti possono compromettere le prestazioni.

Associare ogni new

La regola d'oro è questa: ogni new richiede un delete, e ogni new[] richiede un delete[]. Meglio ancora, lasci che siano i puntatori smart a occuparsene.

Verifica rapida

Verifichi la sua comprensione dell'allocazione nell'heap.

Riepilogo

Ha imparato ad allocare nell'heap con new/new[] e a rilasciare la memoria con delete/delete[]. Gli oggetti nell'heap sopravvivono al proprio ambito, ma richiedono una pulizia manuale. Abbini ogni allocazione, imposti a null i puntatori alla memoria liberata e preferisca std::unique_ptr nel codice moderno.

Domande Frequenti

La lezione «Allocazione nell'heap con new/delete» è gratuita?

Sì — il testo completo di «Allocazione nell'heap con new/delete» è 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 «Allocazione nell'heap con new/delete»?

Gestire la memoria dinamica 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 2 di 4.

Quanto tempo richiede la lezione «Allocazione nell'heap con new/delete»?

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