Ce pointer se folosește împreună cu shared_ptr?

weak_ptr.

#include <memory>
#include <iostream>

int main() {
    auto shared = std::make_shared<int>(10); // Creăm un shared_ptr
    std::weak_ptr<int> weak = shared;      // Creăm un weak_ptr din shared_ptr

    if (auto locked = weak.lock()) {       // Încercăm să obținem un shared_ptr din weak_ptr
        std::cout << "Valoare: " << *locked << std::endl;
    } else {
        std::cout << "Obiect șters." << std::endl;
    }

    shared.reset(); // Obiectul la care pointează shared_ptr este șters

    if (auto locked = weak.lock()) {       // Încercare repetată, obiectul a fost deja șters
        std::cout << "Valoare: " << *locked << std::endl;
    } else {
        std::cout << "Obiect șters." << std::endl;
    }

    return 0;
}

weak_ptr împreună cu shared_ptr este folosit pentru a rezolva problemele de referințe ciclice și pentru a preveni "memory leak" atunci când două sau mai multe obiecte gestionate de shared_ptr se referă reciproc, iar contoarele de referințe nu ating niciodată zero.

Iată principalele proprietăți ale weak_ptr:

• Nu crește contorul de referințe: weak_ptr păstrează o referință "slabă" la obiectul gestionat de shared_ptr, fără a-i crește contorul de referințe puternice.
• Verificarea vieții obiectului: Cu metoda lock(), se poate încerca obținerea unui shared_ptr din weak_ptr. Dacă obiectul este încă viu, lock() va returna un shared_ptr valid; altfel, un shared_ptr gol.
• Fără acces direct: weak_ptr nu oferă acces direct la conținutul obiectului prin operatorii * sau ->. Accesul este posibil doar după un apel reușit la lock().

Utilizarea weak_ptr este o metodă standard de a rupe ciclurile de referințe în structuri de date care folosesc shared_ptr, cum ar fi grafurile sau listele dublu înlănțuite.