Havolalar va const

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

int main()
{
    int son = 10;
    int& havola = son;      // havola - son ning ikkinchi nomi

    std::println("son = {}, havola = {}", son, havola);

    havola = 20;            // havola orqali o'zgartiramiz
    std::println("havola = 20 dan keyin: son = {}", son);

    son = 30;               // asl nom orqali
    std::println("son = 30 dan keyin: havola = {}", havola);

    // Ikkalasining manzili BIR XIL
    std::println("manzillar teng: {}", &son == &havola);

    return 0;
}

struct KattaObyekt
{
    std::vector<int> malumot;
    std::string nom;

    // Nusxa olinganda xabar beradi
    KattaObyekt(std::string n, std::size_t hajm)
        : malumot(hajm, 1), nom(std::move(n)) {}

    KattaObyekt(const KattaObyekt& boshqa)
        : malumot(boshqa.malumot), nom(boshqa.nom)
    {
        std::println("  [nusxa olindi: {} element]", malumot.size());
    }
};

// Qiymat bo'yicha - NUSXA olinadi
void qiymatBoyicha(KattaObyekt obyekt)
{
    std::println("  qiymat bo'yicha: {}", obyekt.nom);
}

// Havola bo'yicha - nusxa YO'Q
void havolaBoyicha(const KattaObyekt& obyekt)
{
    std::println("  havola bo'yicha: {}", obyekt.nom);
}

int main()
{
    KattaObyekt katta{"hisobot", 100000};

    std::println("1. qiymat bo'yicha chaqiruv:");
    qiymatBoyicha(katta);

    std::println("2. havola bo'yicha chaqiruv:");
    havolaBoyicha(katta);

    return 0;
}

void chop(const std::string& matn)
{
    std::println("  chop: '{}'", matn);
}

std::string yasa()
{
    return "funksiyadan qaytgan";
}

int main()
{
    std::string oddiy{"oddiy o'zgaruvchi"};

    chop(oddiy);              // mavjud obyekt
    chop("to'g'ridan-to'g'ri satr");   // vaqtinchalik std::string yasaladi
    chop(yasa());             // funksiya natijasi
    chop(std::string(5, 'x'));        // vaqtinchalik obyekt

    // const BO'LMAGAN havola vaqtinchalik qiymatni QABUL QILMAYDI
    // void ozgartir(std::string& m);
    // ozgartir("satr");      // KOMPILYATSIYA XATOSI

    return 0;
}

int main()
{
    int a = 10;
    int b = 20;

    int& havola = a;
    int* korsatkich = &a;

    std::println("boshlang'ich:  a={} b={}", a, b);

    // Ko'rsatkichni boshqa obyektga o'tkazish mumkin
    korsatkich = &b;
    *korsatkich = 99;
    std::println("korsatkich b ga: a={} b={}", a, b);

    // Havolani o'tkazib BO'LMAYDI - bu a ga yozish demakdir
    havola = b;
    std::println("havola = b:      a={} b={}", a, b);

    // Ko'rsatkich nullptr bo'la oladi
    int* bosh = nullptr;
    std::println("bosh korsatkich: {}", bosh == nullptr);

    return 0;
}

// XATO: mahalliy o'zgaruvchiga havola qaytariladi
const std::string& xatoFunksiya()
{
    std::string mahalliy{"men funksiya tugagach yo'q bo'laman"};
    return mahalliy;          // mahalliy shu yerda yo'q qilinadi
}

// TO'G'RI: qiymat bo'yicha qaytarish
std::string togriFunksiya()
{
    std::string mahalliy{"men xavfsiz ko'chiriladi"};
    return mahalliy;          // ko'chiriladi, nusxa emas
}

int main()
{
    std::println("to'g'ri: {}", togriFunksiya());

    std::println("");
    std::println("xatoFunksiya() ni chaqirish - aniqlanmagan xulq.");
    std::println("Kompilyator ogohlantiradi, lekin taqiqlamaydi.");
    std::println("Bunday kodni ASan bilan ishga tushiring (19-bo'lim).");

    return 0;
}

int main()
{
    std::vector<int> sonlar{10, 20, 30};

    int& birinchi = sonlar[0];
    std::println("birinchi = {}", birinchi);

    birinchi = 99;
    std::println("o'zgartirgandan keyin: {}", sonlar);

    // XAVF: vektor o'sganda xotira KO'CHIRILISHI mumkin
    std::println("");
    std::println("sig'im: {}", sonlar.capacity());

    for (int i = 0; i < 10; ++i) {
        sonlar.push_back(i);
    }

    std::println("qo'shgandan keyin sig'im: {}", sonlar.capacity());
    std::println("birinchi havola endi ISHONCHSIZ");
    std::println("(xotira boshqa joyga ko'chgan bo'lishi mumkin)");

    return 0;
}

int main()
{
    int a = 1;
    int b = 2;

    // const ko'rsatkichning nimasi o'zgarmas?
    const int* p1 = &a;        // ko'rsatilgan QIYMAT o'zgarmas
    int* const p2 = &a;        // KO'RSATKICH o'zgarmas
    const int* const p3 = &a;  // ikkalasi ham

    // *p1 = 10;               // XATO - qiymatni o'zgartirib bo'lmaydi
    p1 = &b;                   // lekin ko'rsatkichni o'zgartirish mumkin

    *p2 = 10;                  // qiymatni o'zgartirish mumkin
    // p2 = &b;                // XATO - ko'rsatkichni o'zgartirib bo'lmaydi

    std::println("a = {}", a);
    std::println("p1 endi b ga ishora qiladi: {}", *p1);
    std::println("p3 orqali: {}", *p3);

    return 0;
}

struct Hisob
{
    std::string egasi;
    int balans;

    // const metod - obyektni O'ZGARTIRMAYDI
    int balansOl() const
    {
        return balans;
    }

    // const emas - o'zgartiradi
    void toldir(int summa)
    {
        balans += summa;
    }
};

void korsat(const Hisob& h)
{
    // const obyektda faqat const metodlarni chaqirish mumkin
    std::println("  {} - {} so'm", h.egasi, h.balansOl());

    // h.toldir(100);      // KOMPILYATSIYA XATOSI
}

int main()
{
    Hisob hisob{"Husanboy", 500000};

    korsat(hisob);

    hisob.toldir(250000);
    korsat(hisob);

    const Hisob ozgarmas{"Malika", 1000000};
    korsat(ozgarmas);
    // ozgarmas.toldir(1);   // KOMPILYATSIYA XATOSI

    return 0;
}