Unique_ptr ishlatilganda qanday qilib xotira oqishini…

Bu qiyin bo‘lsa-da, ma'lum holatlarda mumkin:

Tsiklik bog‘liqliklar (birgalikda egalik qilish, yagona egalikni buzish): Agar ikki unique_ptr bir-biriga murojaat qiladigan obyektlarni egalik qilsa va hech biri birinchi bo‘lib yo‘q qilinmasa, xotira bo‘shatilmaydi. Bu unique_ptr ning yagona egalik prinsipiga zid keladi. Bunday holatlar uchun shared_ptr va weak_ptr yaxshiroq mos keladi.

#include <memory>

struct A;
struct B;

struct A {
    std::unique_ptr<B> ptr_b;
    A() {}
    ~A() { /* A destruktori */ }
};

struct B {
    std::unique_ptr<A> ptr_a; // Bu, A bilan tsiklik bog‘liqlik qiladi
    B() {}
    ~B() { /* B destruktori */ }
};

int main() {
    auto a = std::make_unique<A>();
    auto b = std::make_unique<B>();
    // O‘zaro murojaatlarni o‘rnatamiz
    // Bu, agar a yoki b egasi birinchi bo‘lib o‘zining `unique_ptr`ini yo‘q qilmasa, axiriy oqibatga olib keladi,
    // bu holatda tsiklik bog‘liqlik yuzaga keladi
    a->ptr_b = std::move(b);
    // main’dan chiqib, `a` `unique_ptr<A>` yo‘q qilinadi, lekin uning destruktori
    // `ptr_b`ni yo‘q qilishga harakat qiladi. Ammo, agar `ptr_b` B ob'ektini egallasa,
    // va B ob'ekti, o‘z ichida `unique_ptr<A>` saqlasa, bu A obyektini egallagan,
    // tsiklik bog‘liqlik yuzaga keladi va ehtimol, ehtiyot bo‘lmaslik bilan, sızıntiga olib keladi.
    // Bu misolda, `make_unique` bilan, faqat `a` scope’da qoladi
    // va uning destruktori chaqiriladi. Agar B, A ni egallasa va A, B ni egallasa,
    // muammo yuzaga keladi.
    // Bu yerda, `b` `a->ptr_b` ga ko‘chirildi. `b` endi mainda bo‘sh.
    // main’dan chiqishda, `a` yo‘q qilinadi va destruktori chaqiriladi.
    // `ptr_b` destruktori chaqiriladi.
    // B destruktori chaqiriladi.
    // `unique_ptr<A>` destruktori Bda chaqiriladi.
    // Tsiklik bog‘liqlik muammosi, obyektlar bir-birini yo‘q qilish imkoniga ega bo‘lmagan holatda yuzaga keladi.
    // To‘g‘ri tsiklik bog‘liqlik misoli:
    // struct A { std::unique_ptr<B> b; };
    // struct B { A* a_raw_ptr; }; // B A ni biladi, lekin egallamaydi

    // `unique_ptr` bilan, tsiklik egallash juda kam uchraydi va to‘g‘ridan-to‘g‘ri yaratish qiyin,
    // dizayn xatolari bo‘lmasligi shart. Oddiy tsiklik havola, `unique_ptr` bilan, o‘zi sızıntiga olib kelmaydi,
    // agar tsiklik egallash bo‘lmasa.

    // **Eng realistik tsiklik sızıntı holati:**
    // Agar siz, bir obyekt ichida, `unique_ptr` bilan egallangan boshqa obyektga murojaat qiladigan
    // surov ko‘rsatkich ishlatsangiz, va bu surov ko‘rsatkich, ikkinchi `unique_ptr` tomonidan egallangan obyektga murojaat qilsa,
    // va siz, ikkinchi `unique_ptr` o‘nidan avval o‘chirilganda, surov ko‘rsatkichni reset qilmasangiz,
    // sızıntiga olib keladi.
    // Bu, `unique_ptr` ning o‘zi bilan emas, balki, surov ko‘rsatkich yoki noto‘g‘ri xotira boshqaruvi bilan bog‘liq.

    // `unique_ptr` o‘zi sızıntiga qanday yordam berishi mumkin, unga oid dizayn xatolariga emas.
    // Eng to‘g‘ri usul - bu, istisno.
}

Unique_ptr ishlatilganda qanday qilib xotira oqishini yuzaga keltirish mumkin?