Funksiyalar va lambdalar

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

void korsat(int son)
{
    std::println("int:    {}", son);
}

void korsat(double kasr)
{
    std::println("double: {}", kasr);
}

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

void korsat(const std::vector<int>& royxat)
{
    std::println("vector: {} ta element", royxat.size());
}

int main()
{
    korsat(42);
    korsat(3.14);
    korsat(std::string{"salom"});
    korsat(std::vector<int>{1, 2, 3});

    return 0;
}

std::string bezash(const std::string& matn,
                   char belgi = '*',
                   int kenglik = 30)
{
    if (static_cast<int>(matn.size()) >= kenglik) {
        return matn;
    }

    int qolgan = kenglik - static_cast<int>(matn.size()) - 2;
    int chap = qolgan / 2;
    int ong = qolgan - chap;

    return std::string(chap, belgi) + ' ' + matn + ' '
         + std::string(ong, belgi);
}

int main()
{
    std::println("{}", bezash("Salom"));
    std::println("{}", bezash("Salom", '='));
    std::println("{}", bezash("Salom", '-', 20));

    return 0;
}

int main()
{
    // Eng oddiy lambda
    auto qoshish = [](int a, int b) { return a + b; };

    std::println("qoshish(3, 4) = {}", qoshish(3, 4));

    // Algoritmga uzatish
    std::vector<int> sonlar{5, 2, 8, 1, 9, 3};

    std::ranges::sort(sonlar, [](int a, int b) { return a > b; });
    std::println("kamayish bo'yicha: {}", sonlar);

    auto juftlarSoni = std::ranges::count_if(sonlar,
        [](int x) { return x % 2 == 0; });
    std::println("juft sonlar soni: {}", juftlarSoni);

    // Turlarni aniq yozish shart emas
    auto kvadrat = [](auto x) { return x * x; };
    std::println("kvadrat(5)   = {}", kvadrat(5));
    std::println("kvadrat(2.5) = {}", kvadrat(2.5));

    return 0;
}

int main()
{
    int koeffitsient = 3;
    std::string prefiks{">> "};

    // [] - hech narsa ushlanmaydi
    auto oddiy = [](int x) { return x * 2; };

    // [koeffitsient] - NUSXA olinadi
    auto nusxaBilan = [koeffitsient](int x) { return x * koeffitsient; };

    // [&prefiks] - HAVOLA olinadi
    auto havolaBilan = [&prefiks](const std::string& s) {
        return prefiks + s;
    };

    std::println("oddiy(5)       = {}", oddiy(5));
    std::println("nusxaBilan(5)  = {}", nusxaBilan(5));
    std::println("havolaBilan    = {}", havolaBilan("matn"));

    // Tashqi o'zgaruvchini o'zgartiramiz
    koeffitsient = 100;
    prefiks = "## ";

    std::println("");
    std::println("koeffitsient = 100, prefiks = '## ' dan keyin:");
    std::println("nusxaBilan(5)  = {}  (eski qiymat saqlangan)",
                 nusxaBilan(5));
    std::println("havolaBilan    = {}  (yangi qiymat ko'rindi)",
                 havolaBilan("matn"));

    return 0;
}

// Lambda qaytaruvchi funksiya
std::function<int()> xatoYaratuvchi()
{
    int mahalliy = 42;

    // XAVFLI: mahalliy o'zgaruvchiga havola ushlandi
    return [&mahalliy]() { return mahalliy; };
    // mahalliy shu yerda yo'q qilinadi
}

std::function<int()> togriYaratuvchi()
{
    int mahalliy = 42;

    // XAVFSIZ: nusxa olindi
    return [mahalliy]() { return mahalliy; };
}

int main()
{
    auto togri = togriYaratuvchi();
    std::println("to'g'ri versiya: {}", togri());

    std::println("");
    std::println("xatoYaratuvchi() osilgan havola qaytaradi.");
    std::println("Uni chaqirish - aniqlanmagan xulq-atvor.");
    std::println("ASan bilan ishga tushirilsa darhol topiladi.");

    return 0;
}

int main()
{
    int a = 1;
    double b = 2.0;
    std::string c{"uch"};

    auto hechnarsa = []() { return 0; };
    auto bittasi   = [a]() { return a; };
    auto ikkitasi  = [a, b]() { return a + b; };
    auto uchtasi   = [a, b, c]() { return c; };

    std::println("[]        hajmi: {} bayt", sizeof(hechnarsa));
    std::println("[a]       hajmi: {} bayt", sizeof(bittasi));
    std::println("[a, b]    hajmi: {} bayt", sizeof(ikkitasi));
    std::println("[a, b, c] hajmi: {} bayt", sizeof(uchtasi));

    std::println("");
    std::println("string hajmi:    {} bayt", sizeof(std::string));

    return 0;
}

// Shablon - lambdaning ANIQ turi bilan ishlaydi
template <typename Amal>
int shablonBilan(const std::vector<int>& v, Amal amal)
{
    int soni = 0;
    for (int x : v) {
        if (amal(x)) {
            ++soni;
        }
    }
    return soni;
}

// std::function - istalgan chaqiriladigan narsani qabul qiladi
int funksiyaBilan(const std::vector<int>& v,
                  const std::function<bool(int)>& amal)
{
    int soni = 0;
    for (int x : v) {
        if (amal(x)) {
            ++soni;
        }
    }
    return soni;
}

bool musbatmi(int x) { return x > 0; }

int main()
{
    std::vector<int> v{-3, 5, -1, 8, 0, 12, -7};

    auto lambda = [](int x) { return x > 0; };

    std::println("shablon + lambda:    {}", shablonBilan(v, lambda));
    std::println("shablon + funksiya:  {}", shablonBilan(v, musbatmi));
    std::println("function + lambda:   {}", funksiyaBilan(v, lambda));
    std::println("function + funksiya: {}", funksiyaBilan(v, musbatmi));

    // std::function ni o'zgaruvchida saqlash mumkin
    std::vector<std::function<bool(int)>> shartlar{
        [](int x) { return x > 0; },
        [](int x) { return x % 2 == 0; },
        [](int x) { return x > 10; },
    };

    std::println("");
    const char* nomlar[] = {"musbat", "juft", "10 dan katta"};
    for (std::size_t i = 0; i < shartlar.size(); ++i) {
        std::println("{:<14} {} ta", nomlar[i], funksiyaBilan(v, shartlar[i]));
    }

    return 0;
}

int main()
{
    int hisoblagich = 0;

    // Nusxa ushlangan o'zgaruvchini o'zgartirish uchun mutable kerak
    auto sanovchi = [hisoblagich]() mutable {
        ++hisoblagich;
        return hisoblagich;
    };

    std::println("chaqiruv 1: {}", sanovchi());
    std::println("chaqiruv 2: {}", sanovchi());
    std::println("chaqiruv 3: {}", sanovchi());
    std::println("tashqaridagi hisoblagich: {}", hisoblagich);

    // Havola bilan - tashqaridagisi o'zgaradi
    auto tashqiSanovchi = [&hisoblagich]() {
        ++hisoblagich;
        return hisoblagich;
    };

    std::println("");
    std::println("havola bilan: {}", tashqiSanovchi());
    std::println("havola bilan: {}", tashqiSanovchi());
    std::println("tashqaridagi hisoblagich: {}", hisoblagich);

    return 0;
}

struct Talaba
{
    std::string ism;
    int baho;
};

int main()
{
    std::vector<Talaba> talabalar{
        {"Husanboy", 85}, {"Malika", 92}, {"Nodira", 78},
        {"Aziza", 95},    {"Kamola", 88},
    };

    // Bahoga qarab tartiblash
    std::ranges::sort(talabalar, [](const Talaba& a, const Talaba& b) {
        return a.baho > b.baho;
    });

    std::println("Reyting:");
    for (const auto& t : talabalar) {
        std::println("  {:<10} {}", t.ism, t.baho);
    }

    // 90 dan yuqori baho olganlar
    auto alochilar = std::ranges::count_if(talabalar,
        [](const Talaba& t) { return t.baho >= 90; });

    // O'rtacha baho
    int yigindi = std::accumulate(talabalar.begin(), talabalar.end(), 0,
        [](int jami, const Talaba& t) { return jami + t.baho; });

    std::println("");
    std::println("a'lochilar:  {} ta", alochilar);
    std::println("o'rtacha:    {:.1f}",
                 static_cast<double>(yigindi) / talabalar.size());

    // Eng yuqori baho
    auto eng = std::ranges::max_element(talabalar,
        [](const Talaba& a, const Talaba& b) { return a.baho < b.baho; });
    std::println("eng yuqori:  {} ({})", eng->ism, eng->baho);

    return 0;
}