#include <iostream>

class Dollars
{
private:
    int amount;

public:
    Dollars(int a = 0) : amount(a) {}

    int getAmount() const { return amount; }

    void print() const
    {
        std::cout << "$" << amount;
    }
};

void printMoney(Dollars money)
{
    money.print();
    std::cout << "\n";
}

int main()
{
    Dollars wallet(50);
    printMoney(wallet);  // ✅ Очевидно: передаємо об'єкт Dollars

    // ❓ А це?
    printMoney(100);     // ✅ Компілюється! Чому?
    printMoney(3.14);    // ✅ Теж працює! double → int → Dollars

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    // Конструктор із одним параметром — оператор конвертації int → Fraction
    Fraction(int num) : numerator(num), denominator(1)
    {
        std::cout << "Converting " << num << " to Fraction\n";
    }

    Fraction(int num, int den) : numerator(num), denominator(den) {}

    void print() const
    {
        std::cout << numerator << "/" << denominator;
    }
};

void printFraction(Fraction f)
{
    f.print();
    std::cout << "\n";
}

int main()
{
    Fraction f1(3, 4);
    printFraction(f1);      // ✅ Прямий виклик

    // Неявна конвертація int → Fraction
    printFraction(5);       // ⚠️ Створюється Fraction(5, 1)

    // Неявна конвертація у виразах
    Fraction f2 = 7;        // ⚠️ Еквівалентно Fraction f2(7);

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    // explicit забороняє неявну конвертацію int → Fraction
    explicit Fraction(int num) : numerator(num), denominator(1)
    {
        std::cout << "Explicit constructor called\n";
    }

    Fraction(int num, int den) : numerator(num), denominator(den) {}

    void print() const
    {
        std::cout << numerator << "/" << denominator;
    }
};

void printFraction(Fraction f)
{
    f.print();
    std::cout << "\n";
}

int main()
{
    Fraction f1(3, 4);
    printFraction(f1);      // ✅ Працює

    // ❌ Неявна конвертація заборонена
    // printFraction(5);    // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ✅ Явна конвертація дозволена
    printFraction(Fraction(5));      // Явний виклик конструктора
    printFraction(static_cast<Fraction>(7));  // Явне приведення

    // ❌ Неявна ініціалізація заборонена
    // Fraction f2 = 9;     // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ✅ Явна ініціалізація дозволена
    Fraction f3(9);         // Пряма ініціалізація
    Fraction f4{11};        // Uniform initialization

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    Fraction(int num, int den) : numerator(num), denominator(den) {}

    // Оператор конвертації Fraction → double
    operator double() const
    {
        return static_cast<double>(numerator) / denominator;
    }

    // Оператор конвертації Fraction → int (повертає цілу частину)
    operator int() const
    {
        return numerator / denominator;
    }

    void print() const
    {
        std::cout << numerator << "/" << denominator;
    }
};

void printDouble(double value)
{
    std::cout << "Double: " << value << "\n";
}

void printInt(int value)
{
    std::cout << "Int: " << value << "\n";
}

int main()
{
    Fraction f(7, 2);  // 7/2 = 3.5

    std::cout << "Fraction: ";
    f.print();
    std::cout << "\n\n";

    // Неявна конвертація Fraction → double
    printDouble(f);    // Викликається operator double()

    // Неявна конвертація Fraction → int
    printInt(f);       // Викликається operator int()

    // Явна конвертація через static_cast
    double d = static_cast<double>(f);
    int i = static_cast<int>(f);

    std::cout << "\nExplicit conversions:\n";
    std::cout << "Double: " << d << "\n";
    std::cout << "Int: " << i << "\n";

    // Неявна конвертація у виразах
    double result = f + 1.5;  // f → double, потім 3.5 + 1.5
    std::cout << "\nf + 1.5 = " << result << "\n";

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    Fraction(int num, int den) : numerator(num), denominator(den) {}

    // explicit забороняє неявну конвертацію Fraction → double
    explicit operator double() const
    {
        return static_cast<double>(numerator) / denominator;
    }

    void print() const
    {
        std::cout << numerator << "/" << denominator;
    }
};

void printDouble(double value)
{
    std::cout << "Double: " << value << "\n";
}

int main()
{
    Fraction f(3, 4);

    // ❌ Неявна конвертація заборонена
    // printDouble(f);        // ПОМИЛКА КОМПІЛЯЦІЇ!
    // double d = f;          // ПОМИЛКА КОМПІЛЯЦІЇ!
    // double sum = f + 1.5;  // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ✅ Явна конвертація дозволена
    printDouble(static_cast<double>(f));
    double d = static_cast<double>(f);
    std::cout << "Explicit conversion: " << d << "\n";

    return 0;
}

#include <iostream>

class Pointer
{
private:
    int* ptr;

public:
    Pointer(int* p = nullptr) : ptr(p) {}

    // НЕ explicit — небезпечно!
    operator bool() const
    {
        return ptr != nullptr;
    }
};

int main()
{
    Pointer p1(new int(10));
    Pointer p2(nullptr);

    // ✅ Передбачувана поведінка
    if (p1)
    {
        std::cout << "p1 is not null\n";
    }

    // ❌ Несподівана поведінка: компілюється, але помилка!
    int sum = p1 + p2;  // p1 → bool → int (1), p2 → bool → int (0), sum = 1
    std::cout << "sum = " << sum << "\n";  // sum = 1 — що???

    // ❌ Ще гірше: можна порівнювати з числами!
    if (p1 == 1)  // p1 → bool → int, порівнюємо int == int
    {
        std::cout << "p1 == 1 ?!\n";
    }

    return 0;
}

#include <iostream>

class Pointer
{
private:
    int* ptr;

public:
    Pointer(int* p = nullptr) : ptr(p) {}

    // explicit — безпечно!
    explicit operator bool() const
    {
        return ptr != nullptr;
    }
};

int main()
{
    Pointer p1(new int(10));
    Pointer p2(nullptr);

    // ✅ Використання в умовах працює
    if (p1)
    {
        std::cout << "p1 is not null\n";
    }

    // ❌ Арифметичні операції заборонені
    // int sum = p1 + p2;  // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ❌ Порівняння з числами заборонені
    // if (p1 == 1) {}     // ПОМИЛКА КОМПІЛЯЦІЇ!

    return 0;
}

#include <iostream>

class MyString
{
private:
    char* data;

public:
    MyString(const char* str)
    {
        // Копіюємо рядок
        int length = 0;
        while (str[length] != '\0') ++length;
        data = new char[length + 1];
        for (int i = 0; i <= length; ++i)
        {
            data[i] = str[i];
        }
        std::cout << "MyString constructed from const char*\n";
    }

    // Забороняємо конструктор із char — захист від помилок
    MyString(char) = delete;

    ~MyString()
    {
        delete[] data;
    }
};

int main()
{
    MyString s1("Hello");  // ✅ Працює

    // ❌ Заборонено — захищає від помилки
    // MyString s2('x');   // ПОМИЛКА КОМПІЛЯЦІЇ!
    // MyString s3 = 'A';  // ПОМИЛКА КОМПІЛЯЦІЇ!

    return 0;
}

#include <iostream>

class SafeInt
{
private:
    int value;

public:
    SafeInt(int v) : value(v) {}

    int getValue() const { return value; }

    // Дозволяємо порівняння з іншим SafeInt
    bool operator==(const SafeInt& other) const
    {
        return value == other.value;
    }

    // Забороняємо порівняння з double — може призвести до помилок точності
    bool operator==(double) const = delete;

    // Забороняємо ділення — щоб уникнути цілочисельного ділення без контролю
    SafeInt operator/(const SafeInt&) const = delete;
};

int main()
{
    SafeInt a(10);
    SafeInt b(10);
    SafeInt c(5);

    // ✅ Порівняння між SafeInt працює
    if (a == b)
    {
        std::cout << "a == b\n";
    }

    // ❌ Порівняння з double заборонено
    // if (a == 10.0) {}  // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ❌ Ділення заборонено
    // SafeInt result = a / c;  // ПОМИЛКА КОМПІЛЯЦІЇ!

    return 0;
}

#include <iostream>

class FileHandle
{
private:
    int fileDescriptor;

public:
    FileHandle(const char* filename)
    {
        // Симуляція відкриття файлу
        fileDescriptor = 42;  // Фіктивний дескриптор
        std::cout << "File opened: " << filename << "\n";
    }

    ~FileHandle()
    {
        std::cout << "File closed\n";
    }

    // Забороняємо копіювання — файл не можна дублювати
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    void write(const char* data)
    {
        std::cout << "Writing: " << data << "\n";
    }
};

int main()
{
    FileHandle file("data.txt");
    file.write("Hello, World!");

    // ❌ Копіювання заборонено
    // FileHandle file2 = file;       // ПОМИЛКА КОМПІЛЯЦІЇ!
    // FileHandle file3(file);        // ПОМИЛКА КОМПІЛЯЦІЇ!

    // ❌ Присвоювання заборонено
    // FileHandle file4("other.txt");
    // file4 = file;                  // ПОМИЛКА КОМПІЛЯЦІЇ!

    return 0;
}

#include <iostream>
#include <cmath>

class Money
{
private:
    int dollars;
    int cents;

    void normalize()
    {
        if (cents >= 100)
        {
            dollars += cents / 100;
            cents = cents % 100;
        }
        else if (cents < 0)
        {
            int dollarsBorrowed = (-cents / 100) + 1;
            dollars -= dollarsBorrowed;
            cents += dollarsBorrowed * 100;
        }
    }

public:
    // explicit конструктор — захист від випадкових конвертацій
    explicit Money(int d = 0, int c = 0) : dollars(d), cents(c)
    {
        normalize();
    }

    // Забороняємо конструктор із double — занадто небезпечно для грошей
    Money(double) = delete;

    int getDollars() const { return dollars; }
    int getCents() const { return cents; }

    // explicit конвертація у double — лише явний виклик
    explicit operator double() const
    {
        return dollars + cents / 100.0;
    }

    // Заборона неявної конвертації у int — може призвести до втрати центів
    operator int() const = delete;

    // Дозволяємо явну перевірку на "порожній гаманець"
    explicit operator bool() const
    {
        return dollars != 0 || cents != 0;
    }

    // Оператори порівняння
    bool operator==(const Money& other) const
    {
        return dollars == other.dollars && cents == other.cents;
    }

    bool operator<(const Money& other) const
    {
        if (dollars != other.dollars)
            return dollars < other.dollars;
        return cents < other.cents;
    }

    // Забороняємо порівняння з числами — може призвести до помилок
    bool operator==(int) const = delete;
    bool operator==(double) const = delete;

    friend std::ostream& operator<<(std::ostream& out, const Money& money);
};

std::ostream& operator<<(std::ostream& out, const Money& money)
{
    out << "$" << money.dollars << ".";
    if (money.cents < 10) out << "0";
    out << money.cents;
    return out;
}

int main()
{
    // ✅ Явне створення
    Money wallet(50, 75);
    std::cout << "Wallet: " << wallet << "\n";

    // ❌ Неявна конвертація заборонена
    // Money m1 = 100;           // ПОМИЛКА: explicit конструктор
    // Money m2 = 19.99;         // ПОМИЛКА: конструктор із double видалений

    // ✅ Явне створення дозволено
    Money m3(100);
    Money m4 = Money(25, 50);
    std::cout << "m3: " << m3 << ", m4: " << m4 << "\n";

    // ✅ Використання у булевому контексті
    if (wallet)
    {
        std::cout << "Wallet is not empty\n";
    }

    Money empty;
    if (!empty)
    {
        std::cout << "Empty wallet evaluates to false\n";
    }

    // ✅ Явна конвертація у double
    double value = static_cast<double>(wallet);
    std::cout << "Wallet value: $" << value << "\n";

    // ❌ Заборонені операції
    // int i = wallet;           // ПОМИЛКА: operator int() видалений
    // double d = wallet;        // ПОМИЛКА: explicit operator double()
    // if (wallet == 50) {}      // ПОМИЛКА: operator==(int) видалений

    // ✅ Порівняння між Money працює
    if (m3 == Money(100))
    {
        std::cout << "m3 equals $100.00\n";
    }

    return 0;
}