Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::shared_ptr — proprietà condivisa

std::shared_ptr<T> di <memory> consente di condividere la proprietà di un oggetto. Le copie lo mantengono in vita e il rilascio dell’ultimo proprietario ne avvia la pulizia. std::weak_ptr osserva l’oggetto senza prolungarne la durata.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <memory>
std::shared_ptr<T> p = std::make_shared<T>(args...);
std::shared_ptr<T> q = p;
p.reset();

std::shared_ptr<T> di <memory> rappresenta una proprietà condivisa. Copiandolo, si condivide la proprietà dell’oggetto invece di copiarlo. reset() rilascia la quota di un proprietario; l’ultimo proprietario avvia l’eliminazione dell’oggetto gestito o richiama il deleter appropriato. get() espone soltanto il puntatore memorizzato: non trasferisce la proprietà.

Crea un oggetto con std::make_shared<T>(args...), che inoltra gli argomenti al suo costruttore. Non creare uno std::shared_ptr indipendente a partire da p.get(): così si crea un gruppo di proprietari separato, che può causare una doppia eliminazione. Prima di dereferenziarlo, assicurati che il puntatore memorizzato indichi un oggetto ancora in vita.

I cicli di riferimenti forti possono mantenere gli oggetti in vita a tempo indeterminato. Interrompi un ciclo con std::weak_ptr, che non prolunga la durata dell’oggetto. lock() restituisce uno std::shared_ptr che condivide la proprietà se nel gruppo osservato rimane almeno un proprietario. Se il gruppo è scaduto, lock() restituisce uno std::shared_ptr vuoto anche se l’oggetto è ancora in vita, per esempio perché il deleter non fa nulla.

Una gestione sicura della proprietà non sincronizza i dati dell’oggetto. Istanze diverse che condividono la proprietà possono essere usate contemporaneamente; modificare la stessa istanza richiede sincronizzazione, per esempio con std::atomic<std::shared_ptr<T>>. L’accesso all’oggetto stesso necessita di una protezione separata se è possibile una data race. use_count() non è un meccanismo di sincronizzazione.

L’esempio mostra che q mantiene in vita l’oggetto dopo p.reset() e che l’osservatore scade al termine del blocco. Questa voce riguarda C++23; la bozza di lavoro fornita viene aggiornata e può contenere funzionalità successive. Un’opzione del compilatore nel repository non certifica l’ambiente di esecuzione di produzione.

Esempi

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_shared<int>(42);
    std::weak_ptr<int> observer = p;
    {
        std::shared_ptr<int> q = p;
        p.reset();
        std::cout << *q << '\n';
        std::cout << std::boolalpha << observer.expired() << '\n';
    }
    std::cout << observer.expired() << '\n';
}

Risultato

42
false
true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti