Aqlli ko'rsatkichlar va egalik

#include <print>
#include <string>
#include <vector>
#include <memory>
#include <algorithm>

struct Resurs
{
    std::string nom;

    explicit Resurs(std::string n) : nom(std::move(n))
    {
        std::println("  + {} yaratildi", nom);
    }

    ~Resurs()
    {
        std::println("  - {} yo'q qilindi", nom);
    }

    void ishla() const
    {
        std::println("  {} ishlamoqda", nom);
    }
};

// Bu funksiya obyektni o'chirishi kerakmi? KOD AYTMAYDI.
void nomalum(Resurs* r)
{
    r->ishla();
    // delete r;  ← qilish kerakmi? Bilib bo'lmaydi.
}

int main()
{
    std::println("xom ko'rsatkich:");
    Resurs* xom = new Resurs{"xom"};
    nomalum(xom);
    delete xom;              // chaqiruvchi eslab qolishi kerak

    return 0;
}

struct Resurs
{
    std::string nom;
    explicit Resurs(std::string n) : nom(std::move(n))
    { std::println("  + {}", nom); }
    ~Resurs() { std::println("  - {}", nom); }
    void ishla() const { std::println("  {} ishlamoqda", nom); }
};

void kuzatuvchi(const Resurs& r)      // egalik olmaydi
{
    r.ishla();
}

void egalikOladi(std::unique_ptr<Resurs> r)   // egalik oladi
{
    std::println("  egalik olindi: {}", r->nom);
    // funksiya oxirida obyekt yo'q qilinadi
}

int main()
{
    {
        std::println("qamrov ichida:");
        auto p = std::make_unique<Resurs>("birinchi");

        p->ishla();
        kuzatuvchi(*p);            // hali ham bizniki

        std::println("  p bo'shmi: {}", p == nullptr);
    }
    std::println("qamrovdan chiqdi");

    std::println("");
    std::println("egalikni uzatish:");
    auto q = std::make_unique<Resurs>("ikkinchi");
    egalikOladi(std::move(q));     // move MAJBURIY

    std::println("  q endi bo'shmi: {}", q == nullptr);

    return 0;
}

int main()
{
    std::println("int*                    {} bayt", sizeof(int*));
    std::println("std::unique_ptr<int>    {} bayt",
                 sizeof(std::unique_ptr<int>));
    std::println("std::shared_ptr<int>    {} bayt",
                 sizeof(std::shared_ptr<int>));
    std::println("std::weak_ptr<int>      {} bayt",
                 sizeof(std::weak_ptr<int>));

    std::println("");
    std::println("unique_ptr - nol qo'shimcha xarajat.");
    std::println("shared_ptr - ikki barobar (ko'rsatkich + hisoblagich bloki).");

    return 0;
}

struct Shakl
{
    virtual ~Shakl() = default;
    virtual double yuza() const = 0;
    virtual std::string nomi() const = 0;
};

struct Doira : Shakl
{
    double radius;
    explicit Doira(double r) : radius(r) {}
    double yuza() const override { return 3.14159265 * radius * radius; }
    std::string nomi() const override { return "doira"; }
};

struct Kvadrat : Shakl
{
    double tomon;
    explicit Kvadrat(double t) : tomon(t) {}
    double yuza() const override { return tomon * tomon; }
    std::string nomi() const override { return "kvadrat"; }
};

int main()
{
    std::vector<std::unique_ptr<Shakl>> shakllar;

    shakllar.push_back(std::make_unique<Doira>(2.0));
    shakllar.push_back(std::make_unique<Kvadrat>(3.0));
    shakllar.push_back(std::make_unique<Doira>(1.5));

    double jami = 0;
    for (const auto& s : shakllar) {
        std::println("{:<10} yuza {:.3f}", s->nomi(), s->yuza());
        jami += s->yuza();
    }

    std::println("");
    std::println("jami yuza: {:.3f}", jami);

    // Eng katta shakl
    auto eng = std::ranges::max_element(shakllar,
        [](const auto& a, const auto& b) { return a->yuza() < b->yuza(); });
    std::println("eng katta: {} ({:.3f})", (*eng)->nomi(), (*eng)->yuza());

    // Vektor yo'q qilinganda hamma shakl ham yo'q qilinadi
    return 0;
}

struct Malumot
{
    std::string nom;
    explicit Malumot(std::string n) : nom(std::move(n))
    { std::println("  + {}", nom); }
    ~Malumot() { std::println("  - {}", nom); }
};

int main()
{
    std::shared_ptr<Malumot> birinchi;

    {
        auto a = std::make_shared<Malumot>("umumiy");
        std::println("a yaratildi, egalar soni: {}", a.use_count());

        {
            auto b = a;          // NUSXA - hisoblagich oshadi
            std::println("b nusxa olindi, egalar: {}", a.use_count());

            auto c = a;
            std::println("c nusxa olindi, egalar: {}", a.use_count());
        }

        std::println("b va c qamrovdan chiqdi, egalar: {}", a.use_count());

        birinchi = a;            // tashqariga uzatamiz
        std::println("tashqariga uzatildi, egalar: {}", a.use_count());
    }

    std::println("a qamrovdan chiqdi, egalar: {}", birinchi.use_count());
    std::println("obyekt hali TIRIK - chunki egasi bor");

    std::println("");
    std::println("main tugamoqda:");

    return 0;
}

struct Tugun
{
    std::string nom;
    std::shared_ptr<Tugun> keyingi;

    explicit Tugun(std::string n) : nom(std::move(n))
    { std::println("  + {}", nom); }

    ~Tugun() { std::println("  - {}", nom); }
};

int main()
{
    std::println("1. halqasiz:");
    {
        auto a = std::make_shared<Tugun>("A");
        auto b = std::make_shared<Tugun>("B");
        a->keyingi = b;
        std::println("  A egalari: {}, B egalari: {}",
                     a.use_count(), b.use_count());
    }
    std::println("  ikkalasi ham yo'q qilindi");

    std::println("");
    std::println("2. halqa bilan:");
    {
        auto a = std::make_shared<Tugun>("X");
        auto b = std::make_shared<Tugun>("Y");
        a->keyingi = b;
        b->keyingi = a;          // HALQA
        std::println("  X egalari: {}, Y egalari: {}",
                     a.use_count(), b.use_count());
    }
    std::println("  destruktor CHAQIRILMADI - xotira sizib chiqdi");

    return 0;
}

struct Bola;

struct Ota
{
    std::string nom;
    std::vector<std::shared_ptr<Bola>> bolalar;

    explicit Ota(std::string n) : nom(std::move(n))
    { std::println("  + Ota {}", nom); }

    ~Ota() { std::println("  - Ota {}", nom); }
};

struct Bola
{
    std::string nom;
    std::weak_ptr<Ota> ota;        // WEAK - egalik olmaydi

    explicit Bola(std::string n) : nom(std::move(n))
    { std::println("  + Bola {}", nom); }

    ~Bola() { std::println("  - Bola {}", nom); }

    void otaniAyt() const
    {
        // weak_ptr ni ishlatish uchun lock() kerak
        if (auto p = ota.lock()) {
            std::println("  {} ning otasi: {}", nom, p->nom);
        } else {
            std::println("  {} ning otasi yo'q", nom);
        }
    }
};

int main()
{
    std::shared_ptr<Bola> saqlangan;

    {
        auto ota = std::make_shared<Ota>("Husanboy");
        auto bola = std::make_shared<Bola>("Aziza");

        ota->bolalar.push_back(bola);
        bola->ota = ota;               // weak - hisoblagich oshmaydi

        std::println("");
        std::println("  ota egalari:  {}", ota.use_count());
        std::println("  bola egalari: {}", bola.use_count());

        bola->otaniAyt();
        saqlangan = bola;
    }

    std::println("");
    std::println("qamrovdan chiqdi - ota yo'q qilindi:");
    saqlangan->otaniAyt();

    std::println("");
    std::println("bola hali tirik, chunki uni biz saqladik:");

    return 0;
}

struct Obyekt
{
    int a, b;
    Obyekt(int x, int y) : a(x), b(y) {}
};

int main()
{
    // Tavsiya etiladigan usul
    auto p1 = std::make_unique<Obyekt>(1, 2);
    auto p2 = std::make_shared<Obyekt>(3, 4);

    std::println("make_unique: {} {}", p1->a, p1->b);
    std::println("make_shared: {} {}", p2->a, p2->b);

    // Eski usul - ishlaydi, lekin tavsiya etilmaydi
    std::unique_ptr<Obyekt> p3{new Obyekt{5, 6}};
    std::println("new bilan:   {} {}", p3->a, p3->b);

    std::println("");
    std::println("make_* ning ustunliklari:");
    std::println("  1. 'new' so'zi kodda umuman yo'q");
    std::println("  2. Tur bir marta yoziladi");
    std::println("  3. shared_ptr uchun BITTA xotira ajratish");
    std::println("  4. Istisno xavfsizligi");

    return 0;
}

#include <cstdio>

int main()
{
    // C kutubxonasi resurslarini ham RAII ga o'rash mumkin
    auto fayliniYop = [](std::FILE* f) {
        if (f) {
            std::fclose(f);
            std::println("  [fayl yopildi]");
        }
    };

    {
        std::unique_ptr<std::FILE, decltype(fayliniYop)> fayl{
            std::fopen("/tmp/sr_cpp_sinov.txt", "w"), fayliniYop};

        if (fayl) {
            std::fputs("RAII bilan yozildi\n", fayl.get());
            std::println("  faylga yozildi");
        }
    }
    std::println("qamrovdan chiqdi");

    // O'qib tekshiramiz
    std::println("");
    if (auto f = std::fopen("/tmp/sr_cpp_sinov.txt", "r")) {
        char buf[64]{};
        if (std::fgets(buf, sizeof(buf), f)) {
            std::println("faylda: {}", std::string_view{buf}.substr(0,
                std::string_view{buf}.size() - 1));
        }
        std::fclose(f);
    }

    return 0;
}

int main()
{
    std::println("{:<26} {}", "VAZIYAT", "TANLOV");
    std::println("{}", std::string(64, '-'));
    std::println("{:<26} {}", "Mahalliy obyekt", "oddiy o'zgaruvchi");
    std::println("{:<26} {}", "Sinf a'zosi (qiymat)", "oddiy a'zo");
    std::println("{:<26} {}", "Yagona egalik", "unique_ptr");
    std::println("{:<26} {}", "Egalikni uzatish", "unique_ptr + move");
    std::println("{:<26} {}", "Faqat o'qish (majburiy)", "const T&");
    std::println("{:<26} {}", "Faqat o'qish (ixtiyoriy)", "const T*");
    std::println("{:<26} {}", "Bir necha ega", "shared_ptr");
    std::println("{:<26} {}", "Teskari havola", "weak_ptr");
    std::println("{:<26} {}", "Polimorf konteyner", "vector<unique_ptr<T>>");
    std::println("{:<26} {}", "C resursi", "unique_ptr + o'chiruvchi");

    std::println("");
    std::println("Kodingizda 'new' yoki 'delete' bo'lsa -");
    std::println("deyarli har doim uni almashtirish mumkin.");

    return 0;
}