Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::weak_ptr — osservare senza prolungare la vita dell’oggetto

std::weak_ptr<T> osserva un oggetto gestito da std::shared_ptr senza mantenerlo in vita. Il metodo lock() ottiene temporaneamente un proprietario condiviso oppure uno std::shared_ptr vuoto se la proprietà è già scaduta.

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

Sintassi

#include <memory>
std::weak_ptr<T> observer = owner;
if (auto held = observer.lock()) {
    // Access the object through held.
}

std::weak_ptr<T>, dichiarato in <memory>, memorizza un riferimento debole associato alla proprietà gestita da std::shared_ptr. Non aumenta il numero di proprietari forti e non prolunga la vita dell’oggetto. Costruiscilo a partire da uno std::shared_ptr compatibile oppure lascialo vuoto.

Non mette a disposizione né * né ->. Chiama lock() e controlla lo std::shared_ptr restituito. L’acquisizione della proprietà condivisa è atomica: il metodo restituisce un proprietario condiviso oppure un puntatore vuoto se la proprietà è scaduta, senza generare eccezioni. Mantieni il risultato per tutta la durata dell’accesso all’oggetto.

expired() significa use_count() == 0; use_count() conta i proprietari forti, non gli osservatori. Controllare solo expired() non garantisce la durata dell’oggetto: un altro thread può rilasciare l’ultimo proprietario prima di una successiva chiamata a lock(). L’atomicità di lock() non sincronizza l’accesso ai dati dell’oggetto.

I riferimenti deboli sono utili per osservare e interrompere i cicli di proprietà: un riferimento di ritorno può usare std::weak_ptr invece di un altro proprietario forte. reset() svuota l’osservatore senza distruggere l’oggetto osservato. L’esempio usa funzionalità disponibili in C++23; la bozza attuale dello standard fornita include anche estensioni successive.

Esempi

#include <iostream>
#include <memory>

int main() {
    std::weak_ptr<int> observer;
    {
        auto owner = std::make_shared<int>(42);
        observer = owner;
        if (auto held = observer.lock()) {
            std::cout << *held << '\n';
        }
    }
    std::cout << std::boolalpha << observer.expired() << '\n';
    std::cout << static_cast<bool>(observer.lock()) << '\n';
}

Risultato

42
true
false

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