Perché gli smart pointer sostituiscono new e delete grezzi
Comprenda RAII e perché la gestione di ownership tramite puntatori grezzi è raramente corretta nel C++ moderno
Perché gli smart pointer sostituiscono new e delete grezzi è 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.
new e delete grezzi
L'eredità del C: new T alloca un T nell'heap; delete lo libera. Deve associare ogni new a esattamente un delete, altrimenti si verifica una perdita di memoria o un arresto anomalo.
Widget* w = new Widget();
// ... use w ...
delete w; // forget this and you leakChe cosa può andare storto
Problemi comuni:
deletedimenticato — perdita di memoriadeletedoppio — comportamento non definito- Eccezione generata tra
newedelete— perdita di memoria - Restituzione di un puntatore grezzo con proprietà non chiara
RAII in soccorso
Acquisizione della risorsa = inizializzazione: associa la durata di una risorsa a quella di un oggetto sullo stack. Il distruttore rilascia la risorsa, anche se viene generata un'eccezione.
L'idea del puntatore intelligente
Un puntatore intelligente è un piccolo wrapper RAII attorno a un puntatore grezzo. Il suo distruttore chiama delete. Non rischia di dimenticare la deallocazione.
I tre puntatori intelligenti
I puntatori intelligenti della libreria standard in <memory>:
std::unique_ptr<T>— proprietà esclusivastd::shared_ptr<T>— proprietà condivisa con conteggio dei riferimentistd::weak_ptr<T>— osservatore non proprietario di uno shared_ptr
I puntatori intelligenti hanno un costo ridotto
unique_ptr non introduce overhead: ha le stesse dimensioni e la stessa velocità di un puntatore grezzo. shared_ptr comporta il piccolo costo di un conteggio atomico dei riferimenti.
Niente più delete manuale
Con i puntatori intelligenti, quasi mai dovrà scrivere delete. Il distruttore se ne occupa automaticamente.
#include <memory>
std::unique_ptr<Widget> w = std::make_unique<Widget>();
// no delete needed — when w goes out of scope, Widget is destroyedPuntatori intelligenti ed eccezioni
Se viene generata un'eccezione a metà funzione, le variabili locali vengono distrutte in ordine inverso. I puntatori intelligenti rilasciano automaticamente le proprie risorse; i puntatori grezzi causano perdite di memoria.
La proprietà nel tipo
Ora il tipo del puntatore intelligente codifica la proprietà. Leggendo la firma di una funzione si capisce chi possiede l'oggetto.
// I take ownership
void consume(std::unique_ptr<Widget> w);
// I look but do not own
void inspect(const Widget& w);I puntatori grezzi esistono ancora
Usi puntatori grezzi o riferimenti per l'accesso non proprietario. Comunicano: «sto prendendo in prestito, non possiedo».
Sostituire new con le funzioni make
Preferisca std::make_unique (C++14) e std::make_shared (C++11). Sono sicure rispetto alle eccezioni e leggermente più efficienti rispetto alla chiamata diretta a new.
auto w = std::make_unique<Widget>(42);
auto s = std::make_shared<Resource>("file.txt");Verifica rapida
Qual è il motivo principale per usare std::unique_ptr invece di una coppia grezza new/delete?
Riepilogo
new/delete grezzi sono soggetti a errori. I puntatori intelligenti racchiudono gli oggetti allocati nell'heap in wrapper RAII che li rilasciano automaticamente. Preferisca std::make_unique e std::make_shared per maggiore sicurezza e prestazioni.
Domande Frequenti
La lezione «Perché gli smart pointer sostituiscono new e delete grezzi» è gratuita?
Sì — il testo completo di «Perché gli smart pointer sostituiscono new e delete grezzi» è 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 «Perché gli smart pointer sostituiscono new e delete grezzi»?
Comprenda RAII e perché la gestione di ownership tramite puntatori grezzi è raramente corretta nel C++ moderno 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 «Perché gli smart pointer sostituiscono new e delete grezzi»?
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
- Perché gli smart pointer sostituiscono new e delete grezzi
- unique_ptr e ownership esclusiva
- shared_ptr e weak_ptr: ownership condivisa
- Deleter personalizzati e funzioni make