#include <iostream>
#include <string>
#include <cstdint>

// Record: чистий опис сутності, всі поля публічні
struct Product
{
    std::string name;
    uint32_t    sku;        // Stock Keeping Unit — артикул
    double      price;
    int         quantity;
};

// Всі операції — через вільні функції
void printProduct(const Product& p)
{
    std::cout << "[" << p.sku << "] " << p.name
              << " — " << p.price << " грн ("
              << p.quantity << " шт.)\n";
}

double totalValue(const Product& p)
{
    return p.price * p.quantity;
}

bool isAvailable(const Product& p)
{
    return p.quantity > 0;
}

int main()
{
    Product laptop = { "Ноутбук Dell XPS 13", 100042, 42999.0, 5 };
    Product mouse  = { "Миша Logitech MX3",   200017,  2499.0, 0 };

    printProduct(laptop);
    std::cout << "Загальна вартість: " << totalValue(laptop) << " грн\n";
    std::cout << "Є в наявності: " << (isAvailable(laptop) ? "Так" : "Ні") << "\n\n";

    printProduct(mouse);
    std::cout << "Є в наявності: " << (isAvailable(mouse) ? "Так" : "Ні") << "\n";

    return 0;
}

#include <iostream>
#include <cstdint>
#include <cmath>

struct Color
{
    uint8_t r;
    uint8_t g;
    uint8_t b;
};

struct Money
{
    long long  cents;    // зберігаємо у центах/копійках, уникаємо float
    std::string currency;
};

// Value Object: порівняння через поля, не через адресу
bool colorsEqual(const Color& a, const Color& b)
{
    return a.r == b.r && a.g == b.g && a.b == b.b;
}

Color blendColors(const Color& a, const Color& b)
{
    return
    {
        static_cast<uint8_t>((a.r + b.r) / 2),
        static_cast<uint8_t>((a.g + b.g) / 2),
        static_cast<uint8_t>((a.b + b.b) / 2),
    };
}

Money addMoney(const Money& a, const Money& b)
{
    // Спрощення: вважаємо, що валюти однакові
    return { a.cents + b.cents, a.currency };
}

void printColor(const Color& c)
{
    std::cout << "rgb(" << (int)c.r << ", " << (int)c.g << ", " << (int)c.b << ")";
}

void printMoney(const Money& m)
{
    std::cout << m.cents / 100 << "." << m.cents % 100 << " " << m.currency;
}

int main()
{
    Color red     = { 255, 0,   0   };
    Color blue    = { 0,   0,   255 };
    Color blended = blendColors(red, blue);

    std::cout << "Red:     "; printColor(red);     std::cout << "\n";
    std::cout << "Blue:    "; printColor(blue);    std::cout << "\n";
    std::cout << "Blended: "; printColor(blended); std::cout << "\n";

    // Семантика значення: blended — повністю незалежна копія
    Color copy = blended;
    copy.r = 0; // не впливає на blended

    std::cout << "Blended після copy.r=0: "; printColor(blended); std::cout << "\n";

    Money salary  = { 5000000, "UAH" }; // 50 000.00 UAH
    Money bonus   = {  750000, "UAH" }; //  7 500.00 UAH
    Money total   = addMoney(salary, bonus);

    std::cout << "Зарплата: "; printMoney(salary); std::cout << "\n";
    std::cout << "Бонус:    "; printMoney(bonus);  std::cout << "\n";
    std::cout << "Разом:    "; printMoney(total);  std::cout << "\n";

    return 0;
}

#include <iostream>
#include <string>

// Result type: завжди чітко — успіх чи помилка і чому
struct ParseResult
{
    bool        ok;      // true якщо парсинг успішний
    int         value;   // результат (має сенс лише якщо ok == true)
    std::string error;   // опис помилки (має сенс лише якщо ok == false)
};

// Функція-парсер: не кидає виключень, повертає Result
ParseResult parseInt(const std::string& input)
{
    if (input.empty())
        return { false, 0, "Порожній рядок" };

    // Перевірка, чи всі символи — цифри (або перший — знак)
    int start = 0;
    if (input[0] == '-' || input[0] == '+')
        start = 1;

    if (start == static_cast<int>(input.size()))
        return { false, 0, "Лише знак без цифр" };

    for (int i = start; i < static_cast<int>(input.size()); ++i)
    {
        if (input[i] < '0' || input[i] > '9')
            return { false, 0, "Некоректний символ: '" + std::string(1, input[i]) + "'" };
    }

    return { true, std::stoi(input), "" };
}

void handleResult(const ParseResult& r, const std::string& input)
{
    if (r.ok)
        std::cout << "\"" << input << "\" → " << r.value << "\n";
    else
        std::cout << "\"" << input << "\" → Помилка: " << r.error << "\n";
}

int main()
{
    handleResult(parseInt("42"),      "42");
    handleResult(parseInt("-17"),     "-17");
    handleResult(parseInt(""),        "");
    handleResult(parseInt("12a3"),    "12a3");
    handleResult(parseInt("+"),       "+");

    return 0;
}

#include <iostream>
#include <string>

struct SortOptions
{
    bool ascending  = true;   // за зростанням (true) або спаданням (false)
    bool ignoreCase = false;  // ігнорувати регістр при порівнянні рядків
    bool stable     = false;  // стабільне сортування (зберегти відносний порядок рівних)
};

struct SearchOptions
{
    bool caseSensitive = true;   // чутливість до регістру
    bool wholeWord     = false;  // шукати ціле слово, не підрядок
    int  maxResults    = 10;     // максимальна кількість результатів
};

void sortDemo(const std::string* arr, int size, const SortOptions& opts)
{
    std::cout << "Сортування: "
              << (opts.ascending  ? "за зростанням" : "за спаданням") << ", "
              << (opts.ignoreCase ? "без урахування регістру" : "з урахуванням регістру") << ", "
              << (opts.stable     ? "стабільне" : "нестабільне") << "\n";
    // Реальна логіка сортування тут...
}

void searchDemo(const std::string& query, const SearchOptions& opts)
{
    std::cout << "Пошук \"" << query << "\": "
              << (opts.caseSensitive ? "чутливо" : "нечутливо") << " до регістру, "
              << (opts.wholeWord     ? "ціле слово" : "підрядок") << ", "
              << "макс. " << opts.maxResults << " результатів\n";
}

int main()
{
    std::string names[] = { "Аліса", "боб", "Крістіна", "дмитро" };

    // Явно і читабельно через designated initializers
    SortOptions opts1 = { .ascending = true, .ignoreCase = true };
    sortDemo(names, 4, opts1);

    // Значення за замовчуванням для невказаних полів
    SortOptions opts2 = { .ascending = false };
    sortDemo(names, 4, opts2);

    SearchOptions searchOpts = { .caseSensitive = false, .maxResults = 5 };
    searchDemo("аліса", searchOpts);

    return 0;
}

#include <iostream>
#include <string>
#include <cmath>

// Технічно коректно — але чи семантично правильно?
struct Point2D
{
    double x;
    double y;

    // Метод всередині struct
    double distanceTo(const Point2D& other) const
    {
        double dx = x - other.x;
        double dy = y - other.y;
        return std::sqrt(dx*dx + dy*dy);
    }

    void print() const
    {
        std::cout << "(" << x << ", " << y << ")";
    }
};

int main()
{
    Point2D a = { 0.0, 0.0 };
    Point2D b = { 3.0, 4.0 };

    a.print();
    std::cout << " → ";
    b.print();
    std::cout << " : відстань = " << a.distanceTo(b) << "\n";

    return 0;
}