Operatorlar va qiymat semantikasi

#include <print>
#include <string>
#include <vector>
#include <compare>
#include <format>
#include <stdexcept>
#include <algorithm>

// Yalang'och sonlar - hech narsa xato qilishga to'sqinlik qilmaydi
long long summa(long long sum, long long dollar)
{
    return sum + dollar;          // MA'NOSIZ, lekin kompilyatsiya qilinadi
}

int main()
{
    long long narx_sum = 150'000;
    long long narx_dollar = 12;

    std::println("bema'ni qo'shuv: {}", summa(narx_sum, narx_dollar));
    std::println("kompilyator hech nima demadi.");

    std::println("");
    std::println("Yana bir muammo - vergul qayerda:");
    long long tiyin = 15'000'050;
    std::println("  xom son:  {}", tiyin);
    std::println("  har safar qo'lda formatlash kerak");

    return 0;
}

class Pul
{
    long long tiyin_{};          // eng kichik birlikda saqlaymiz

public:
    Pul() = default;

    static Pul somdan(long long som, int tiyin = 0)
    {
        Pul p;
        p.tiyin_ = som * 100 + tiyin;
        return p;
    }

    long long tiyin() const { return tiyin_; }

    Pul& operator+=(const Pul& b) { tiyin_ += b.tiyin_; return *this; }
    Pul& operator-=(const Pul& b) { tiyin_ -= b.tiyin_; return *this; }
    Pul& operator*=(int n)        { tiyin_ *= n;        return *this; }

    std::string matn() const
    {
        long long musbat = tiyin_ < 0 ? -tiyin_ : tiyin_;
        const char* ishora = tiyin_ < 0 ? "-" : "";
        return std::format("{}{}.{:02} so'm", ishora, musbat / 100, musbat % 100);
    }
};

// Ikki argumentli operatorlar - erkin funksiya
Pul operator+(Pul a, const Pul& b) { a += b; return a; }
Pul operator-(Pul a, const Pul& b) { a -= b; return a; }
Pul operator*(Pul a, int n)        { a *= n; return a; }
Pul operator*(int n, Pul a)        { a *= n; return a; }

int main()
{
    Pul non = Pul::somdan(4'000);
    Pul sut = Pul::somdan(12'500, 50);

    std::println("non: {}", non.matn());
    std::println("sut: {}", sut.matn());

    Pul jami = non + sut;
    std::println("jami: {}", jami.matn());

    Pul uchta = non * 3;
    std::println("uchta non: {}", uchta.matn());

    Pul teskari = 2 * sut;
    std::println("ikki sut: {}", teskari.matn());

    Pul qarz = non - sut;
    std::println("farq: {}", qarz.matn());

    std::println("");
    // Pul + 5   ← kompilyatsiya xatosi. Aynan shuni xohlagandik.

    return 0;
}

class Versiya
{
    int katta_{};
    int orta_{};
    int kichik_{};

public:
    Versiya(int a, int b, int c) : katta_(a), orta_(b), kichik_(c) {}

    // Bitta qator - oltita operator
    auto operator<=>(const Versiya&) const = default;
    bool operator==(const Versiya&) const = default;

    std::string matn() const
    {
        return std::format("{}.{}.{}", katta_, orta_, kichik_);
    }
};

int main()
{
    Versiya a{1, 4, 0};
    Versiya b{1, 10, 0};
    Versiya c{1, 4, 0};

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

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

    std::println("");
    std::vector<Versiya> ro = {{2, 0, 0}, {1, 4, 0}, {1, 10, 3}, {1, 4, 7}};
    std::ranges::sort(ro);

    std::print("saralangan:");
    for (const auto& v : ro) std::print(" {}", v.matn());
    std::println("");

    return 0;
}

class Talaba
{
    std::string ism_;
    double ball_{};

public:
    Talaba(std::string ism, double ball)
        : ism_(std::move(ism)), ball_(ball) {}

    // Avval ballga ko'ra (kamayish), keyin ismga ko'ra
    std::weak_ordering operator<=>(const Talaba& b) const
    {
        if (ball_ != b.ball_) {
            return ball_ > b.ball_ ? std::weak_ordering::less
                                   : std::weak_ordering::greater;
        }
        return ism_ <=> b.ism_;      // strong_ordering -> weak_ordering
    }

    bool operator==(const Talaba& b) const
    {
        return ball_ == b.ball_ && ism_ == b.ism_;
    }

    const std::string& ism() const { return ism_; }
    double ball() const { return ball_; }
};

int main()
{
    std::vector<Talaba> guruh = {
        {"Nodira",   88.5},
        {"Husanboy", 94.0},
        {"Aziza",    94.0},
        {"Kamola",   76.25},
        {"Malika",   88.5},
    };

    std::ranges::sort(guruh);

    std::println("{:<10} {}", "ISM", "BALL");
    std::println("{}", std::string(20, '-'));
    for (const auto& t : guruh) {
        std::println("{:<10} {:.2f}", t.ism(), t.ball());
    }

    std::println("");
    std::println("eng yuqori: {}", guruh.front().ism());
    std::println("eng past:   {}", guruh.back().ism());

    return 0;
}

class Matritsa
{
    std::size_t satr_{};
    std::size_t ustun_{};
    std::vector<double> ma_;

public:
    Matritsa(std::size_t s, std::size_t u)
        : satr_(s), ustun_(u), ma_(s * u, 0.0) {}

    // Ikki indeksli kirish - operator()
    double& operator()(std::size_t s, std::size_t u)
    {
        if (s >= satr_ || u >= ustun_) throw std::out_of_range{"chegaradan tashqari"};
        return ma_[s * ustun_ + u];
    }

    double operator()(std::size_t s, std::size_t u) const
    {
        if (s >= satr_ || u >= ustun_) throw std::out_of_range{"chegaradan tashqari"};
        return ma_[s * ustun_ + u];
    }

    std::size_t satrlar() const { return satr_; }
    std::size_t ustunlar() const { return ustun_; }

    void chop(const std::string& nom) const
    {
        std::println("{}:", nom);
        for (std::size_t s = 0; s < satr_; ++s) {
            std::string qator;
            for (std::size_t u = 0; u < ustun_; ++u) {
                qator += std::format("{:7.2f}", (*this)(s, u));
            }
            std::println("  {}", qator);
        }
    }
};

Matritsa operator*(const Matritsa& a, const Matritsa& b)
{
    if (a.ustunlar() != b.satrlar()) throw std::invalid_argument{"o'lcham mos emas"};

    Matritsa n{a.satrlar(), b.ustunlar()};
    for (std::size_t s = 0; s < a.satrlar(); ++s) {
        for (std::size_t u = 0; u < b.ustunlar(); ++u) {
            double jami = 0;
            for (std::size_t k = 0; k < a.ustunlar(); ++k) jami += a(s, k) * b(k, u);
            n(s, u) = jami;
        }
    }
    return n;
}

int main()
{
    Matritsa a{2, 3};
    a(0,0) = 1; a(0,1) = 2; a(0,2) = 3;
    a(1,0) = 4; a(1,1) = 5; a(1,2) = 6;

    Matritsa b{3, 2};
    b(0,0) = 7;  b(0,1) = 8;
    b(1,0) = 9;  b(1,1) = 10;
    b(2,0) = 11; b(2,1) = 12;

    a.chop("A");
    b.chop("B");

    Matritsa c = a * b;
    c.chop("A * B");

    std::println("");
    try {
        a(5, 0) = 1;
    } catch (const std::out_of_range& x) {
        std::println("xato tutildi: {}", x.what());
    }

    return 0;
}

struct Nuqta
{
    double x{};
    double y{};
};

// std::format uchun o'z turimizni ro'yxatdan o'tkazamiz
template <>
struct std::formatter<Nuqta>
{
    constexpr auto parse(std::format_parse_context& c) { return c.begin(); }

    auto format(const Nuqta& n, std::format_context& c) const
    {
        return std::format_to(c.out(), "({:.2f}, {:.2f})", n.x, n.y);
    }
};

Nuqta operator+(const Nuqta& a, const Nuqta& b) { return {a.x + b.x, a.y + b.y}; }
Nuqta operator*(const Nuqta& a, double k)       { return {a.x * k, a.y * k}; }

int main()
{
    Nuqta a{3.0, 4.0};
    Nuqta b{1.5, -2.0};

    std::println("a       = {}", a);
    std::println("b       = {}", b);
    std::println("a + b   = {}", a + b);
    std::println("a * 2   = {}", a * 2.0);

    std::println("");
    std::vector<Nuqta> yol = {{0,0}, {1,1}, {3,2}, {3,5}};
    for (std::size_t i = 0; i < yol.size(); ++i) {
        std::println("  {}-nuqta: {}", i, yol[i]);
    }

    return 0;
}

int main()
{
    std::println("{:<24} {}", "OPERATOR", "MASLAHAT");
    std::println("{}", std::string(58, '-'));
    std::println("{:<24} {}", "&&  ||", "YUKLAMANG - qisqa hisob yo'qoladi");
    std::println("{:<24} {}", ",", "YUKLAMANG - tartib yo'qoladi");
    std::println("{:<24} {}", "&  (manzil olish)", "YUKLAMANG - hamma chalg'iydi");
    std::println("{:<24} {}", "->", "Faqat aqlli ko'rsatkichda");
    std::println("{:<24} {}", "()", "Faqat funksiya-obyektda");
    std::println("{:<24} {}", "new  delete", "Faqat ajratgich yozayotganda");
    std::println("{:<24} {}", "+ - * /", "Faqat MATEMATIK ma'noda");
    std::println("{:<24} {}", "<=>  ==", "Deyarli har doim = default");

    std::println("");
    std::println("Oltin qoida:");
    std::println("  Operator ma'nosini o'zgartirmang.");
    std::println("  Shubha bo'lsa - nomli funksiya yozing.");
    std::println("  qoshildi() - g'alati operator+ dan ravshanroq.");

    return 0;
}