Aniqlanmagan xatti-harakat

#include <print>
#include <string>
#include <vector>
#include <limits>
#include <bit>
#include <cstdint>
#include <cstring>

int main()
{
    std::println("Turlar chegarasi:");
    std::println("  int:       {} .. {}",
                 std::numeric_limits<int>::min(),
                 std::numeric_limits<int>::max());
    std::println("  unsigned:  {} .. {}",
                 std::numeric_limits<unsigned>::min(),
                 std::numeric_limits<unsigned>::max());

    std::println("");
    std::println("Ishorasiz TO'LIB KETISH aniqlangan (modul arifmetikasi):");
    unsigned u = std::numeric_limits<unsigned>::max();
    std::println("  UINT_MAX + 1 = {}", u + 1);

    std::println("");
    std::println("Ishorali to'lib ketish esa UB.");
    std::println("Kompilyator INT_MAX + 1 hech qachon bo'lmaydi deb faraz qiladi.");

    std::println("");
    std::println("Xavfsiz tekshirish:");
    int a = std::numeric_limits<int>::max();
    int natija = 0;
    bool tolib = __builtin_add_overflow(a, 1, &natija);
    std::println("  INT_MAX + 1 to'lib ketdimi: {}", tolib);

    tolib = __builtin_add_overflow(100, 200, &natija);
    std::println("  100 + 200 to'lib ketdimi:   {} (natija {})", tolib, natija);

    return 0;
}

mkdir -p ub && cd ub

cat > tolish.cpp <<'EOF'
#include <cstdio>

int oshir(int x)
{
    return x + 1;
}

int main()
{
    int katta = 2147483647;      // INT_MAX
    std::printf("boshlang'ich: %d\n", katta);
    std::printf("natija:       %d\n", oshir(katta));
    return 0;
}
EOF

echo "--- sanitayzersiz ---"
g++ -std=c++23 -O1 -o tolish tolish.cpp
./tolish

echo ""
echo "--- UBSan bilan ---"
g++ -std=c++23 -O1 -fsanitize=undefined -o tolish_ub tolish.cpp
./tolish_ub 2>&1 | sed 's|^.*/||'

cat > chegara.cpp <<'EOF'
#include <cstdio>
#include <vector>

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

    std::printf("v[0] = %d\n", v[0]);
    std::printf("v[2] = %d\n", v[2]);

    // Chegaradan chiqish - operator[] TEKSHIRMAYDI
    std::printf("v[5] = %d\n", v[5]);

    return 0;
}
EOF

g++ -std=c++23 -O1 -g -fsanitize=address -o chegara chegara.cpp
./chegara > chiqish.txt 2>&1
kod=$?

echo "chiqish kodi nol emasmi: $([ $kod -ne 0 ] && echo ha || echo yoq)"
echo ""
grep -o "ERROR: AddressSanitizer: [a-z-]*" chiqish.txt
grep -c "READ of size" chiqish.txt | xargs printf "o'qish xatolari: %s\n"
grep -o "chegara.cpp:[0-9]*" chiqish.txt | head -1

cat > keyin.cpp <<'EOF'
#include <cstdio>
#include <vector>

int main()
{
    std::vector<int> v{1, 2, 3};
    int* p = &v[0];

    std::printf("qayta ajratishdan oldin: %d\n", *p);

    for (int i = 0; i < 1000; ++i) v.push_back(i);   // qayta ajratish

    std::printf("qayta ajratishdan keyin: %d\n", *p);  // OSILGAN ko'rsatkich
    return 0;
}
EOF

g++ -std=c++23 -O1 -g -fsanitize=address -o keyin keyin.cpp
./keyin > k.txt 2>&1

grep -o "ERROR: AddressSanitizer: [a-z-]*" k.txt
grep -o "freed by thread" k.txt | head -1
grep -o "previously allocated by thread" k.txt | head -1
echo ""
echo "Sabab: push_back xotirani qayta ajratdi va eski blokni bo'shatdi."

cat > sizish.cpp <<'EOF'
#include <cstdio>

int* yarat(int n)
{
    return new int[n];           // hech qachon delete[] qilinmaydi
}

int main()
{
    int* a = yarat(100);
    a[0] = 42;
    std::printf("a[0] = %d\n", a[0]);

    int* b = yarat(50);
    b[0] = 7;
    std::printf("b[0] = %d\n", b[0]);

    return 0;                    // ikkala blok ham sizib chiqdi
}
EOF

g++ -std=c++23 -O1 -g -fsanitize=address -o sizish sizish.cpp
./sizish > s.txt 2>&1

grep -o "ERROR: LeakSanitizer: [a-z ]*" s.txt
grep -o "SUMMARY: AddressSanitizer: [0-9]* byte(s) leaked in [0-9]* allocation(s)" s.txt
echo ""
echo "100 int = 400 bayt, 50 int = 200 bayt, jami 600 bayt."

cat > osilgan.cpp <<'EOF'
#include <cstdio>
#include <string>

const std::string& yomon()
{
    std::string mahalliy = "vaqtinchalik";
    return mahalliy;              // MAHALLIY obyektga havola
}

int main()
{
    std::printf("chaqirmoqchimiz...\n");
    const std::string& h = yomon();
    std::printf("uzunlik: %zu\n", h.size());
    return 0;
}
EOF

echo "--- kompilyator ogohlantiradimi ---"
g++ -std=c++23 -Wall -Wextra -O1 -c -o /dev/null osilgan.cpp 2>&1 | grep -c "warning" | xargs printf "ogohlantirishlar soni: %s\n"
g++ -std=c++23 -Wall -Wextra -O1 -c -o /dev/null osilgan.cpp 2>&1 | grep -o "reference to local variable .* returned"

echo ""
echo "--- ASan bilan ishga tushirish ---"
g++ -std=c++23 -O1 -g -fsanitize=address -o osilgan osilgan.cpp 2>/dev/null
./osilgan > o.txt 2>&1
grep -o "ERROR: AddressSanitizer: [A-Za-z-]*" o.txt
echo "osilgan xotiraga murojaat qilindi: $(grep -c "SEGV" o.txt)"

int main()
{
    float f = 3.14159f;

    std::println("float qiymat: {}", f);

    // NOTO'G'RI: reinterpret_cast bilan tur qoidasini buzish
    // std::uint32_t* p = reinterpret_cast<std::uint32_t*>(&f);
    // std::println("{}", *p);        <- qat'iy taxallus qoidasini buzadi

    // TO'G'RI 1: std::bit_cast (C++20)
    auto bitlar = std::bit_cast<std::uint32_t>(f);
    std::println("bit ko'rinishi: {:#010x}", bitlar);
    std::println("ikkilikda:      {:032b}", bitlar);

    // TO'G'RI 2: std::memcpy - kompilyator uni optimallashtiradi
    std::uint32_t nusxa{};
    std::memcpy(&nusxa, &f, sizeof(f));
    std::println("memcpy natijasi bir xilmi: {}", nusxa == bitlar);

    std::println("");
    std::println("Orqaga aylantirish:");
    float qayta = std::bit_cast<float>(bitlar);
    std::println("  qayta olingan: {}", qayta);
    std::println("  bir xilmi:     {}", qayta == f);

    std::println("");
    std::println("IEEE 754 qismlari:");
    std::println("  ishora:   {}", (bitlar >> 31) & 1u);
    std::println("  daraja:   {}", (bitlar >> 23) & 0xFFu);
    std::println("  mantissa: {:#x}", bitlar & 0x7FFFFFu);

    return 0;
}

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

    std::println("Chegara tekshiruvi:");
    std::println("  v[1]      = {}  (tekshirmaydi)", v[1]);
    std::println("  v.at(1)   = {}  (tekshiradi)", v.at(1));

    try {
        std::println("  v.at(99)  = {}", v.at(99));
    } catch (const std::out_of_range& x) {
        std::println("  v.at(99) -> istisno tutildi");
    }

    std::println("");
    std::println("Bo'sh konteyner:");
    std::vector<int> bosh;
    std::println("  bosh.empty()  = {}", bosh.empty());
    std::println("  bosh.size()   = {}", bosh.size());
    std::println("  bosh.front()  = UB - CHAQIRMANG");

    std::println("");
    std::println("Xavfsiz naqshlar:");
    if (!bosh.empty()) {
        std::println("  birinchi: {}", bosh.front());
    } else {
        std::println("  konteyner bo'sh - front() chaqirilmadi");
    }

    std::println("");
    std::println("Diapazon bo'yicha tsikl - indeks umuman yo'q:");
    for (int x : v) std::print(" {}", x);
    std::println("");

    std::println("");
    std::println("Ko'rsatkich o'rniga indeks:");
    std::size_t joy = 1;
    v.push_back(40);                  // qayta ajratish bo'lishi mumkin
    std::println("  v[{}] = {} (indeks omon qoldi)", joy, v[joy]);

    return 0;
}