Turlar va o'zgaruvchilar

#include <print>
#include <string>
#include <vector>
#include <cstdint>
#include <limits>
#include <typeinfo>

int main()
{
    std::println("{:<12} {:>5} {}", "TUR", "BAYT", "DIAPAZON");
    std::println("{}", std::string(52, '-'));

    std::println("{:<12} {:>5} {} .. {}", "char", sizeof(char),
                 static_cast<int>(std::numeric_limits<char>::min()),
                 static_cast<int>(std::numeric_limits<char>::max()));
    std::println("{:<12} {:>5} {} .. {}", "short", sizeof(short),
                 std::numeric_limits<short>::min(),
                 std::numeric_limits<short>::max());
    std::println("{:<12} {:>5} {} .. {}", "int", sizeof(int),
                 std::numeric_limits<int>::min(),
                 std::numeric_limits<int>::max());
    std::println("{:<12} {:>5} {} .. {}", "long long", sizeof(long long),
                 std::numeric_limits<long long>::min(),
                 std::numeric_limits<long long>::max());
    std::println("{:<12} {:>5} ~{:.1e}", "float", sizeof(float),
                 std::numeric_limits<float>::max());
    std::println("{:<12} {:>5} ~{:.1e}", "double", sizeof(double),
                 std::numeric_limits<double>::max());
    std::println("{:<12} {:>5}", "bool", sizeof(bool));

    return 0;
}

int main()
{
    std::int8_t   a = 127;
    std::int16_t  b = 32767;
    std::int32_t  c = 2147483647;
    std::int64_t  d = 9223372036854775807;
    std::uint32_t e = 4294967295;

    std::println("int8_t   {} bayt, qiymat {}", sizeof(a), a);
    std::println("int16_t  {} bayt, qiymat {}", sizeof(b), b);
    std::println("int32_t  {} bayt, qiymat {}", sizeof(c), c);
    std::println("int64_t  {} bayt, qiymat {}", sizeof(d), d);
    std::println("uint32_t {} bayt, qiymat {}", sizeof(e), e);

    // Indekslar va o'lchamlar uchun
    std::vector<int> v{1, 2, 3};
    std::println("size_t   {} bayt, v.size() = {}", sizeof(std::size_t),
                 v.size());

    return 0;
}

int main()
{
    int a = 5;        // nusxa initsializatsiyasi (C dan meros)
    int b(5);         // to'g'ridan-to'g'ri
    int c{5};         // qavsli - C++11 dan, TAVSIYA ETILADI

    std::println("a={} b={} c={}", a, b, c);

    // Farq shu yerda ko'rinadi
    double kasr = 3.99;

    int eski = kasr;          // jimgina kesiladi
    std::println("int eski = 3.99;  natija: {}", eski);

    // int yangi{kasr};       // KOMPILYATSIYA XATOSI - torayish
    std::println("int yangi{{3.99}};  kompilyatsiya qilinmaydi");

    return 0;
}

int main()
{
    auto son = 42;                    // int
    auto kasr = 3.14;                 // double
    auto belgi = 'A';                 // char
    auto rost = true;                 // bool
    auto matn = std::string{"salom"}; // std::string

    std::println("son:   {} ({} bayt)", son, sizeof(son));
    std::println("kasr:  {} ({} bayt)", kasr, sizeof(kasr));
    std::println("belgi: {} ({} bayt)", belgi, sizeof(belgi));
    std::println("rost:  {}", rost);
    std::println("matn:  {} ({} belgi)", matn, matn.size());

    // auto uzun turlarni qisqartiradi
    std::vector<std::string> ismlar{"Husanboy", "Malika"};

    for (auto it = ismlar.begin(); it != ismlar.end(); ++it) {
        std::println("iterator orqali: {}", *it);
    }

    return 0;
}

int main()
{
    std::vector<std::string> ismlar{"Husanboy", "Malika", "Nodira"};

    // Nusxa - har elementda satr ko'chiriladi
    for (auto ism : ismlar) {
        ism += "!";               // asl nusxaga ta'sir qilmaydi
    }
    std::println("auto bilan:        {}", ismlar);

    // Havola - nusxa yo'q, o'zgartirish mumkin
    for (auto& ism : ismlar) {
        ism += "!";
    }
    std::println("auto& bilan:       {}", ismlar);

    // Faqat o'qish - nusxa ham yo'q, o'zgartirish ham
    for (const auto& ism : ismlar) {
        std::print("{} ", ism.size());
    }
    std::println("<- uzunliklar");

    return 0;
}

constexpr int kvadrat(int x)
{
    return x * x;
}

int main()
{
    const int oddiy = 10;              // ish vaqtida o'zgarmas
    constexpr int doimiy = 20;         // KOMPILYATSIYA paytida ma'lum

    // constexpr qiymat massiv o'lchami bo'la oladi
    int massiv[doimiy];
    massiv[0] = 1;

    // constexpr funksiya kompilyatsiya paytida hisoblanadi
    constexpr int natija = kvadrat(12);

    std::println("oddiy:   {}", oddiy);
    std::println("doimiy:  {}", doimiy);
    std::println("massiv:  {} element", std::size(massiv));
    std::println("kvadrat: {} (kompilyatsiya paytida hisoblangan)", natija);

    // O'sha funksiya ish vaqtida ham ishlaydi
    int kiritma = 7;
    std::println("ish vaqtida: {}", kvadrat(kiritma));

    return 0;
}

// Eski uslub - nomlar tashqariga chiqadi
enum EskiRang { Qizil, Yashil, Kok };

// Zamonaviy - nomlar o'z sohasida qoladi
enum class Rang { Qizil, Yashil, Kok };
enum class Holat { Yangi, Qizil, Tugagan };   // Qizil takrorlandi - muammo yo'q

int main()
{
    EskiRang eski = Qizil;
    Rang yangi = Rang::Qizil;

    // Eski enum jimgina int ga aylanadi
    int son = eski;
    std::println("eski enum int ga aylandi: {}", son);

    // Yangisi aylanmaydi - aniq yozish kerak
    std::println("yangi enum: {}", static_cast<int>(yangi));

    // int songa = yangi;      // KOMPILYATSIYA XATOSI

    // Solishtirishda ham xavfsiz
    // if (yangi == Holat::Qizil)   // KOMPILYATSIYA XATOSI - turlar boshqa

    std::println("Rang::Kok      = {}", static_cast<int>(Rang::Kok));
    std::println("Holat::Tugagan = {}", static_cast<int>(Holat::Tugagan));

    return 0;
}

void ishla(int son)
{
    std::println("ishla(int) chaqirildi, son = {}", son);
}

void ishla(const char* matn)
{
    std::println("ishla(const char*) chaqirildi, matn = {}",
                 matn == nullptr ? "(null)" : matn);
}

int main()
{
    ishla(42);
    ishla("salom");

    // NULL yoki 0 - qaysi funksiya chaqiriladi?
    ishla(0);            // int versiyasi!

    // nullptr - aniq ko'rsatkich
    ishla(nullptr);      // const char* versiyasi

    return 0;
}

#include <map>

int main()
{
    // Eski usul
    typedef std::map<std::string, std::vector<int>> EskiTur;

    // Zamonaviy usul - o'qish osonroq
    using BaholarJadvali = std::map<std::string, std::vector<int>>;

    BaholarJadvali baholar{
        {"Husanboy", {85, 92, 78}},
        {"Malika", {95, 88, 91}},
    };

    for (const auto& [ism, royxat] : baholar) {   // strukturaviy bog'lash
        int yigindi = 0;
        for (int b : royxat) {
            yigindi += b;
        }
        std::println("{:<10} {} ta baho, o'rtacha {:.1f}",
                     ism, royxat.size(),
                     static_cast<double>(yigindi) / royxat.size());
    }

    return 0;
}

#include <cmath>

int main()
{
    double a = 0.1 + 0.2;
    double b = 0.3;

    std::println("0.1 + 0.2 = {:.20f}", a);
    std::println("0.3       = {:.20f}", b);
    std::println("a == b ?    {}", a == b);
    std::println("farq:       {:.2e}", std::abs(a - b));

    // To'g'ri solishtirish - epsilon bilan
    constexpr double epsilon = 1e-9;
    std::println("|a-b| < eps ? {}", std::abs(a - b) < epsilon);

    return 0;
}