C++ da aqlli ko'rsatkichlar haqida nima bilasiz…

Aqlli ko'rsatkichlar C++ da oddiy (xom) ko'rsatkichlar ustiga RAII-qoplamlar bo'lib, ajratilgan xotira hayotini avtomatik boshqarishni ta'minlaydi va oqishni oldini oladi.

C++ standarti kutubxonasida asosiy aqlli ko'rsatkich turlari:

std::unique_ptr
std::shared_ptr
std::weak_ptr

std::unique_ptr

Resursni eksklyuziv tarzda egallaydi.
Nusxa ko'chirilmaydi, lekin ko'chirilishi mumkin.
Resursning yagona egaligini ta'minlash uchun ishlatiladi.
Qo'shimcha xarajatlar minimal, xom ko'rsatkichga teng.

// unique_ptr misoli
#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    std::cout << *ptr << std::endl; // 10
    // std::unique_ptr<int> ptr2 = ptr; // Kompilyatsiya xatosi: unique_ptr nusxa ko'chirilmaydi
    std::unique_ptr<int> ptr3 = std::move(ptr); // Egallashni ko'chirish
    std::cout << *ptr3 << std::endl; // 10
    // std::cout << *ptr << std::endl; // Belgilangan xatti-harakat: ptr endi bo'sh
    return 0;
}

std::shared_ptr

Bir nechta ko'rsatkichlar birgalikda resursni egallashiga imkon beradi.
Referenslar hisoblagichi ishlatiladi. Hisoblagich nolga tushganda, xotira bo'shatiladi.
Nusxa ko'chirilishi mumkin. Har bir nusxa referenslar hisoblagichini oshiradi.
unique_ptr ga nisbatan yuqori xarajatlar, hisoblagichni boshqarish uchun.

// shared_ptr misoli
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 1)
    std::shared_ptr<int> ptr2 = ptr1; // Nusxa, use_count oshadi
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 2)
    std::shared_ptr<int> ptr3 = ptr1; // Yana nusxa
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 3)
    return 0;
}

std::weak_ptr

Resursni egallamaydi va referenslar hisoblagichini oshirmaydi.
shared_ptr orasidagi siklik referenslarni hal qilish uchun ishlatiladi.
shared_ptr tomonidan ko'rsatilgan resursga kirish imkonini beradi, lekin uni o'chirishni oldini olmaydi.
Resursga kirish uchun, weak_ptr ni shared_ptr ga aylantirish kerak, lock() metodidan foydalanib.

// weak_ptr misoli
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> shared_ptr_int = std::make_shared<int>(30);
    std::weak_ptr<int> weak_ptr_int = shared_ptr_int;

    if (auto locked_ptr = weak_ptr_int.lock()) {
        std::cout << *locked_ptr << std::endl; // 30
    } else {
        std::cout << "Resurs bo'shatildi." << std::endl;
    }

    shared_ptr_int.reset(); // Resurs bo'shatiladi

    if (auto locked_ptr = weak_ptr_int.lock()) {
        std::cout << *locked_ptr << std::endl;
    } else {
        std::cout << "Resurs bo'shatildi." << std::endl; // Resurs bo'shatildi.
    }
    return 0;
}

Aqlli ko'rsatkichlardan foydalanish zamonaviy C++ da yaxshi amaliyot hisoblanadi, chunki bu xotira boshqaruvidagi xatolik ehtimolini sezilarli darajada kamaytiradi.

C++ da aqlli ko'rsatkichlar haqida nima bilasiz?