std::weak_ptr

Deși std::shared_ptr este extrem de utilă, baza exclusiv pe proprietatea comună poate duce la o problemă cunoscută sub numele de referință circulară (sau dependență ciclică).

Dacă două sau mai multe obiecte conţin fiecare un shared_ptr care indică către celălalt, se creează o buclă închisă. În această situație, numărul de referințe al niciunui obiect nu va ajunge vreodată la zero, prevenind dealocarea și provocând o scurgere de memorie.

Ce este std::weak_ptr

Pentru a întrerupe ciclurile de proprietate, biblioteca standard oferă std::weak_ptr. Acesta este un pointer inteligent care observă un obiect gestionat de un shared_ptr, dar fără a crește numărul de referințe.

Nu deține direct resursa, așa că nu împiedică distrugerea acesteia.

#include <memory>

std::shared_ptr<int> shared = std::make_shared<int>(42);
std::weak_ptr<int> weak = shared; // Does not increment reference count!

Verificarea și accesarea resursei

Deoarece un weak_ptr nu deține resursa, resursa poate fi dealocată în orice moment (când toate instanțele shared_ptr asociate ies din domeniul de aplicare).

Pentru a folosi resursa observată, trebuie să:

1. Verificați dacă este încă valabil utilizând expired().
2. Transformați temporar weak_ptr într-un shared_ptr folosind metoda lock(). Dacă resursa este încă activă, lock() returnează un shared_ptr valid, în caz contrar, returnează un pointer nul (nullptr).

if (!weak.expired()) {
    // lock() creates a temporary shared_ptr to ensure safe access
    if (std::shared_ptr<int> sharedAccess = weak.lock()) {
        std::cout << *sharedAccess << std::endl;
    }
} else {
    std::cout << "Resource deallocated!" << std::endl;
}

Încercați-l singur