Qaysi asosda bir nechta shared_ptr ob'ektlari bir xil…

Bir nechta std::shared_ptr obyekti, kontrol bloki (control block) mavjudligi tufayli, bir xil ko'rsatgichga murojaat qilishi mumkin.

Boshqaruv bloki, boshqarilayotgan ob'ekt bilan bog'liq bo'lib, quyidagilarni o'z ichiga oladi:

Mustahkam referenslar hisoblagichi (strong reference count): Yangi shared_ptr yaratilganda, aynan shu ob'ekt uchun oshadi. shared_ptr yo'q qilinayotganda kamayadi. Agar nolga teng bo'lsa, bog'langan ob'ekt (ko'rsatgich) o'chiriladi.
Zaif referenslar hisoblagichi (weak reference count): std::weak_ptr uchun ishlatiladi. shared_ptr dan weak_ptr yaratilganda oshadi. weak_ptr yo'q qilinayotganda kamayadi. Ikkala hisoblagich ham nolga teng bo'lsa, boshqaruv bloki o'chiriladi.
Boshqarilayotgan ob'ektga o'ziga xos ko'rsatgich: Ma'lumotlar ko'rsatgichidan farqli o'laroq, boshqaruv bloki tomonidan boshqariladi.

Agar siz mavjud shared_ptr dan yangi shared_ptr yaratsangiz (nusxa, tayinlash-nusxa), ular bir xil boshqaruv blokidan foydalanishni boshlaydi va bu blokdagi mustahkam referenslar hisoblagichi oshadi.

Misol:

#include <memory>
#include <iostream>

struct MyData {
    int value;
    MyData(int v) : value(v) { std::cout << "MyData(" << value << ") yaratildi.\n"; }
    ~MyData() { std::cout << "MyData(" << value << ") o'chirildi.\n"; }
};

int main() {
    // Birinchi shared_ptr yaratiladi.
    // Boshqaruv bloki va MyData ob'ekti yaratiladi.
    // Hisoblagichlar: kuchli: 1, zaif: 0.
    std::shared_ptr<MyData> ptr1 = std::make_shared<MyData>(10);
    std::cout << "ptr1 ning foydalanish hisoblagichi: " << ptr1.use_count() << "\n";

    // ptr1 dan ikkinchi shared_ptr yaratiladi.
    // Bir xil boshqaruv bloki ishlatiladi.
    // Kuchli hisoblagich 2 ga oshadi.
    std::shared_ptr<MyData> ptr2 = ptr1;
    std::cout << "ptr1 ning foydalanish hisoblagichi: " << ptr1.use_count() << "\n";
    std::cout << "ptr2 ning foydalanish hisoblagichi: " << ptr2.use_count() << "\n";

    // ptr1 dan uchinchi shared_ptr yaratiladi.
    // Bir xil boshqaruv bloki ishlatiladi.
    // Kuchli hisoblagich 3 ga oshadi.
    std::shared_ptr<MyData> ptr3 = ptr1;
     std::cout << "ptr1 ning foydalanish hisoblagichi: " << ptr1.use_count() << "\n";
    std::cout << "ptr2 ning foydalanish hisoblagichi: " << ptr2.use_count() << "\n";
    std::cout << "ptr3 ning foydalanish hisoblagichi: " << ptr3.use_count() << "\n";

    std::cout << "Doiradan chiqish.\n";
    // ptr3 doiradan chiqadi.
    // Kuchli hisoblagich 2 ga tushadi.
    // ptr2 doiradan chiqadi.
    // Kuchli hisoblagich 1 ga tushadi.
    // ptr1 doiradan chiqadi.
    // Kuchli hisoblagich 0 ga tushadi.
    // MyData ob'ekti o'chiriladi.
    // Boshqaruv bloki o'chiriladi.
}

Har bir shared_ptr obyekti o'zining boshqaruv bloki ko'rsatgichiga va o'zining ma'lumotlar ko'rsatgichiga ega. shared_ptr nusxa ko'chirilganda, ikkala ko'rsatgich ham nusxa ko'chiriladi va umumiy boshqaruv blokidagi kuchli referenslar hisoblagichi oshadi. Shu tarzda, barcha shared_ptrlar bir xil boshqaruv blokiga murojaat qiladi, u ularning nusxalarining egalik sonini kuzatadi va boshqarilayotgan resursning o'lim vaqtini belgilaydi.

Qaysi asosda bir nechta shared_ptr ob'ektlari bir xil ko'rsatkichga murojaat qilishi mumkin?