Vorislik va polimorfizm

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

class Xodim
{
    std::string ism_;
    long long oylik_;

public:
    Xodim(std::string ism, long long oylik)
        : ism_(std::move(ism)), oylik_(oylik) {}

    virtual ~Xodim() = default;          // MAJBURIY

    const std::string& ism() const { return ism_; }
    long long oylik() const { return oylik_; }

    virtual long long oylikTolov() const { return oylik_; }
    virtual std::string lavozim() const { return "xodim"; }
};

class Dasturchi : public Xodim
{
    int loyihalar_;

public:
    Dasturchi(std::string ism, long long oylik, int loyihalar)
        : Xodim(std::move(ism), oylik), loyihalar_(loyihalar) {}

    long long oylikTolov() const override
    {
        return oylik() + loyihalar_ * 500'000;
    }

    std::string lavozim() const override { return "dasturchi"; }
};

class Menejer : public Xodim
{
    int qol_ostidagilar_;

public:
    Menejer(std::string ism, long long oylik, int qol)
        : Xodim(std::move(ism), oylik), qol_ostidagilar_(qol) {}

    long long oylikTolov() const override
    {
        return oylik() + qol_ostidagilar_ * 200'000;
    }

    std::string lavozim() const override { return "menejer"; }
};

int main()
{
    std::vector<std::unique_ptr<Xodim>> jamoa;
    jamoa.push_back(std::make_unique<Dasturchi>("Husanboy", 8'000'000, 3));
    jamoa.push_back(std::make_unique<Menejer>("Nodira", 9'000'000, 6));
    jamoa.push_back(std::make_unique<Xodim>("Kamola", 5'000'000));

    long long jami = 0;
    for (const auto& x : jamoa) {
        std::println("{:<10} {:<11} {:>10}", x->ism(), x->lavozim(), x->oylikTolov());
        jami += x->oylikTolov();
    }

    std::println("{}", std::string(33, '-'));
    std::println("{:<22} {:>10}", "JAMI", jami);

    return 0;
}

class Asos
{
public:
    virtual ~Asos() = default;
    virtual void ishla(int n) const { std::println("  Asos::ishla({})", n); }
    virtual void tekshir() const     { std::println("  Asos::tekshir()"); }
};

class Voris : public Asos
{
public:
    // override YOZILGAN - kompilyator imzoni tekshiradi
    void ishla(int n) const override { std::println("  Voris::ishla({})", n); }

    // override YOZILMAGAN - va imzo mos emas (const yo'q)
    // Bu YANGI funksiya, qayta aniqlash EMAS
    void tekshir() { std::println("  Voris::tekshir() - const YO'Q"); }
};

int main()
{
    Voris v;
    Asos& a = v;

    std::println("Asos havolasi orqali:");
    a.ishla(5);
    a.tekshir();          // Asos ning versiyasi - kutilmagan!

    std::println("");
    std::println("To'g'ridan-to'g'ri:");
    v.ishla(5);
    v.tekshir();

    std::println("");
    std::println("Ikkinchi holatda ikki xil funksiya chaqirildi.");
    std::println("override yozilganida kompilyator xato berardi.");

    return 0;
}

struct Shakl
{
    virtual ~Shakl() = default;
    virtual std::string nomi() const { return "shakl"; }
    virtual double yuza() const { return 0.0; }
};

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

void qiymatBoyicha(Shakl s)         // KESILADI
{
    std::println("  qiymat bo'yicha: {} yuza {:.3f}", s.nomi(), s.yuza());
}

void havolaBoyicha(const Shakl& s)  // to'g'ri
{
    std::println("  havola bo'yicha: {} yuza {:.3f}", s.nomi(), s.yuza());
}

int main()
{
    Doira d{2.0};

    std::println("Doira{{2.0}} - haqiqiy yuzasi {:.3f}", d.yuza());
    std::println("");

    havolaBoyicha(d);
    qiymatBoyicha(d);

    std::println("");
    std::println("Konteynerda ham xuddi shunday:");
    std::vector<Shakl> yomon;
    yomon.push_back(Doira{3.0});
    std::println("  vector<Shakl> ichida: {} yuza {:.3f}",
                 yomon[0].nomi(), yomon[0].yuza());

    std::vector<std::unique_ptr<Shakl>> yaxshi;
    yaxshi.push_back(std::make_unique<Doira>(3.0));
    std::println("  vector<unique_ptr> ichida: {} yuza {:.3f}",
                 yaxshi[0]->nomi(), yaxshi[0]->yuza());

    return 0;
}

// Sof virtual funksiya - ta'rifsiz
class Toshkichik
{
public:
    virtual ~Toshkichik() = default;
    virtual bool tolash(long long tiyin) = 0;
    virtual std::string nomi() const = 0;
    virtual long long komissiya(long long tiyin) const = 0;
};

class Karta : public Toshkichik
{
    long long balans_;

public:
    explicit Karta(long long balans) : balans_(balans) {}

    bool tolash(long long tiyin) override
    {
        long long jami = tiyin + komissiya(tiyin);
        if (jami > balans_) return false;
        balans_ -= jami;
        return true;
    }

    std::string nomi() const override { return "karta"; }
    long long komissiya(long long tiyin) const override { return tiyin / 100; }
    long long balans() const { return balans_; }
};

class Naqd : public Toshkichik
{
public:
    bool tolash(long long) override { return true; }
    std::string nomi() const override { return "naqd"; }
    long long komissiya(long long) const override { return 0; }
};

void xarid(Toshkichik& usul, long long narx)
{
    bool natija = usul.tolash(narx);
    std::println("  {:<6} {:>10} tiyin, komissiya {:>6}, natija: {}",
                 usul.nomi(), narx, usul.komissiya(narx), natija);
}

int main()
{
    Karta k{1'000'000};
    Naqd n;

    std::println("to'lovlar:");
    xarid(k, 300'000);
    xarid(n, 300'000);
    xarid(k, 900'000);

    std::println("");
    std::println("kartada qoldi: {} tiyin", k.balans());

    // Toshkichik t;   ← kompilyatsiya xatosi: abstrakt sinf

    return 0;
}

// YOMON: Stack Vector dan voris qilingan
// class Stack : public std::vector<int> { };
// Muammo: Stack endi push_back, insert, operator[] ni ham beradi

// YAXSHI: kompozitsiya
class Stek
{
    std::vector<int> ma_;          // A'ZO, bazaviy sinf emas

public:
    void qoy(int q) { ma_.push_back(q); }

    int ol()
    {
        int oxirgi = ma_.back();
        ma_.pop_back();
        return oxirgi;
    }

    int tepa() const { return ma_.back(); }
    bool boshmi() const { return ma_.empty(); }
    std::size_t soni() const { return ma_.size(); }
};

int main()
{
    Stek s;
    s.qoy(10);
    s.qoy(20);
    s.qoy(30);

    std::println("elementlar: {}", s.soni());
    std::println("tepa: {}", s.tepa());

    std::println("");
    std::print("chiqarish tartibi:");
    while (!s.boshmi()) std::print(" {}", s.ol());
    std::println("");

    std::println("");
    std::println("Stek faqat 5 ta amalni ochadi.");
    std::println("vector dan voris qilinsa - 40 dan ortiq amal ochilardi,");
    std::println("shu jumladan stek qoidasini buzadiganlari.");

    return 0;
}

class Hisoblagich
{
    std::string nom_;
    int qiymat_{};
    std::function<void(int)> ozgarganda_;

public:
    explicit Hisoblagich(std::string nom) : nom_(std::move(nom)) {}

    void kuzat(std::function<void(int)> f) { ozgarganda_ = std::move(f); }

    void osir(int n = 1)
    {
        qiymat_ += n;
        if (ozgarganda_) ozgarganda_(qiymat_);
    }

    int qiymat() const { return qiymat_; }
    const std::string& nom() const { return nom_; }
};

int main()
{
    Hisoblagich h{"tashriflar"};

    std::println("kuzatuvchisiz:");
    h.osir();
    h.osir(5);
    std::println("  qiymat: {}", h.qiymat());

    std::println("");
    std::println("kuzatuvchi bilan:");
    int ogohlantirish = 0;
    h.kuzat([&ogohlantirish](int q) {
        std::println("  o'zgardi -> {}", q);
        if (q > 10) ++ogohlantirish;
    });

    h.osir(3);
    h.osir(4);
    h.osir();

    std::println("");
    std::println("10 dan oshgan holatlar: {}", ogohlantirish);
    std::println("Bu yerda birorta virtual funksiya yo'q.");

    return 0;
}

struct Bazaviy
{
    virtual ~Bazaviy() = default;
    virtual int hisobla(int n) const { return n; }
};

struct Voris : Bazaviy
{
    int hisobla(int n) const override { return n * 2; }
};

struct Oddiy
{
    int hisobla(int n) const { return n * 2; }
};

int main()
{
    std::println("Bo'sh oddiy sinf:      {} bayt", sizeof(Oddiy));
    std::println("Bo'sh virtual sinf:    {} bayt", sizeof(Bazaviy));
    std::println("Ko'rsatkich hajmi:     {} bayt", sizeof(void*));
    std::println("");
    std::println("Virtual sinfda yashirin jadval ko'rsatkichi bor.");
    std::println("Bo'sh oddiy sinf 1 bayt - chunki C++ da har bir");
    std::println("obyektning manzili boshqacha bo'lishi kerak.");

    std::println("");
    std::println("Chaqiruv narxi:");
    std::println("  oddiy:   to'g'ridan-to'g'ri, inline bo'lishi mumkin");
    std::println("  virtual: jadvaldan o'qish + bilvosita chaqiruv");
    std::println("  inline BO'LMAYDI (odatda)");

    std::unique_ptr<Bazaviy> p = std::make_unique<Voris>();
    std::println("");
    std::println("virtual natija:  {}", p->hisobla(21));
    Oddiy o;
    std::println("oddiy natija:    {}", o.hisobla(21));

    return 0;
}