shared_ptr e weak_ptr: ownership condivisa
Condivida l'ownership tramite il conteggio dei riferimenti e interrompa i cicli con weak_ptr
shared_ptr e weak_ptr: ownership condivisa è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Condividere un oggetto
A volte più parti del programma devono mantenere in vita lo stesso oggetto. std::shared_ptr<T> gestisce la proprietà condivisa tramite il conteggio dei riferimenti.
Creazione di shared_ptr
Usi std::make_shared: alloca il blocco di controllo e l'oggetto in un'unica allocazione.
#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count(); // 1La copia condivide la proprietà
La copia di uno shared_ptr incrementa il conteggio dei riferimenti. La sua distruzione o riassegnazione lo decrementa. Quando il conteggio raggiunge 0, l'oggetto viene eliminato.
auto a = std::make_shared<Widget>();
auto b = a; // ref count is now 2
std::cout << a.use_count(); // 2Come funziona internamente
Uno shared_ptr contiene due puntatori: uno all'oggetto e uno a un blocco di controllo che contiene il conteggio o i conteggi dei riferimenti. Il blocco di controllo viene allocato nell'heap.
Conteggio atomico dei riferimenti
Il conteggio dei riferimenti usa operazioni atomiche, quindi gli shared_ptr possono essere copiati tra thread in modo sicuro. Tuttavia, l'oggetto puntato non è automaticamente sicuro per l'accesso concorrente.
Reimpostazione e riassegnazione
L'assegnazione di un nuovo valore decrementa il vecchio conteggio dei riferimenti e incrementa quello nuovo. reset() imposta lo shared_ptr come vuoto.
shared_ptr da puntatore grezzo (da evitare)
Non costruisca due shared_ptr a partire dallo stesso puntatore grezzo: ciascuno avrebbe il proprio blocco di controllo. Usi sempre make_shared.
// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw); // disaster: two control blocksIl problema dei cicli
Due shared_ptr che si referenziano a vicenda formano un ciclo: il conteggio dei riferimenti di nessuno dei due raggiunge zero e nessuno viene deallocato. Si verifica una perdita di memoria.
struct Node {
std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // cycle — never freedInterrompere i cicli con weak_ptr
std::weak_ptr<T> osserva uno shared_ptr senza partecipare al conteggio dei riferimenti. Renda debole un lato della relazione per interrompere il ciclo.
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak — does not own
};Usare weak_ptr
Non è possibile dereferenziare direttamente un weak_ptr. Chiami lock() per ottenere uno shared_ptr, oppure un puntatore vuoto se l'oggetto è stato distrutto.
std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
p->use(); // safe — we have a shared_ptr now
} else {
std::cout << "object expired";
}Costo rispetto a unique_ptr
shared_ptr è più grande (due puntatori più il blocco di controllo) e più lento (a causa del conteggio atomico dei riferimenti). Lo usi solo quando la proprietà deve essere realmente condivisa.
Verifica rapida
Qual è il caso d'uso tipico di std::weak_ptr?
Riepilogo
shared_ptr tiene traccia della proprietà tramite un conteggio atomico dei riferimenti. Usi make_shared, presti attenzione ai cicli e li interrompa con weak_ptr. Preferisca unique_ptr quando non è necessario condividere la proprietà.
Domande Frequenti
La lezione «shared_ptr e weak_ptr: ownership condivisa» è gratuita?
Sì — il testo completo di «shared_ptr e weak_ptr: ownership condivisa» è 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 «shared_ptr e weak_ptr: ownership condivisa»?
Condivida l'ownership tramite il conteggio dei riferimenti e interrompa i cicli con weak_ptr 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 3 di 4.
Quanto tempo richiede la lezione «shared_ptr e weak_ptr: ownership condivisa»?
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