#include <iostream>

class Seconds
{
private:
    int totalSeconds;

public:
    Seconds(int initialSeconds = 0) : totalSeconds(initialSeconds) {}

    int getTotalSeconds() const
    {
        return totalSeconds;
    }

    void print() const
    {
        std::cout << totalSeconds << " s";
    }
};

void setTimer(Seconds duration)
{
    std::cout << "Timer set for: ";
    duration.print();
    std::cout << "\n";
}

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

    // ❓ А це?
    setTimer(100);     // ⚠️ Компілюється! Чому?
    setTimer(3.14);    // ⚠️ Працює з втратою даних! double → int → Seconds

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

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

    Fraction(int numeratorValue, int denominatorValue)
        : numerator(numeratorValue), denominator(denominatorValue) {}

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

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

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

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

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

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

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

    Fraction(int numeratorValue, int denominatorValue)
        : numerator(numeratorValue), denominator(denominatorValue) {}

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

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

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

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

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

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

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

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    Fraction(int numeratorValue, int denominatorValue)
        : numerator(numeratorValue), denominator(denominatorValue)
    {
    }

    // Оператор конвертації Fraction → double
    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 fraction(7, 2);  // 7/2 = 3.5

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

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

    // Явна конвертація через static_cast
    double doubleValue = static_cast<double>(fraction);

    std::cout << "\nExplicit conversion:\n";
    std::cout << "Double: " << doubleValue << "\n";

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

    return 0;
}

#include <iostream>

class Fraction
{
private:
    int numerator;
    int denominator;

public:
    Fraction(int numeratorValue, int denominatorValue)
        : numerator(numeratorValue), denominator(denominatorValue)
    {
    }

    // 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 fraction(3, 4);

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

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

    return 0;
}

#include <iostream>

class SmartPointer
{
private:
    int* managedPointer;

public:
    explicit SmartPointer(int* initialPointer = nullptr) : managedPointer(initialPointer) {}

    ~SmartPointer()
    {
        delete managedPointer;
    }

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

int main()
{
    SmartPointer firstPointer(new int(10));
    SmartPointer secondPointer(nullptr);

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

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

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

    return 0;
}

#include <iostream>

class SmartPointer
{
private:
    int* managedPointer;

public:
    explicit SmartPointer(int* initialPointer = nullptr) : managedPointer(initialPointer) {}

    ~SmartPointer()
    {
        delete managedPointer;
    }

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

int main()
{
    SmartPointer firstPointer(new int(10));
    SmartPointer secondPointer(nullptr);

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

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

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

    return 0;
}

#include <iostream>

class MyString
{
private:
    char* textBuffer;

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

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

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

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

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

    return 0;
}

#include <iostream>

class SafeInt
{
private:
    int storedValue;

public:
    explicit SafeInt(int initialValue) : storedValue(initialValue) {}

    int getValue() const { return storedValue; }

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

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

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

int main()
{
    SafeInt firstNumber(10);
    SafeInt secondNumber(10);
    SafeInt thirdNumber(5);

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

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

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

    return 0;
}

#include <iostream>

class FileHandle
{
private:
    int fileDescriptor;

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

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

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

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

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

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

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

    return 0;
}

#include <iostream>
#include <cstdint>

class MemorySize
{
private:
    uint64_t bytesCount;

public:
    // explicit конструктор — захист від випадкових конвертацій
    explicit MemorySize(uint64_t initialBytes) : bytesCount(initialBytes) {}

    // Конструктор за замовчуванням та для цілочисельних літералів int
    explicit MemorySize(int initialBytes = 0)
        : bytesCount(initialBytes >= 0 ? static_cast<uint64_t>(initialBytes) : 0)
    {
    }

    // Забороняємо конструктор із double — байти не можуть бути дробовими
    MemorySize(double) = delete;

    uint64_t getBytes() const
    {
        return bytesCount;
    }

    // explicit конвертація у double (мегабайти) — лише явний виклик
    explicit operator double() const
    {
        return static_cast<double>(bytesCount) / (1024.0 * 1024.0);
    }

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

    // Дозволяємо явну перевірку на ненульовий розмір
    explicit operator bool() const
    {
        return bytesCount > 0;
    }

    // Оператори порівняння між об'єктами MemorySize
    bool operator==(const MemorySize& otherSize) const
    {
        return bytesCount == otherSize.bytesCount;
    }

    bool operator<(const MemorySize& otherSize) const
    {
        return bytesCount < otherSize.bytesCount;
    }

    // Забороняємо порівняння з числами — захист від плутанини одиниць вимірювання
    bool operator==(int) const = delete;
    bool operator==(double) const = delete;

    friend std::ostream& operator<<(std::ostream& outputStream, const MemorySize& memorySize);
};

std::ostream& operator<<(std::ostream& outputStream, const MemorySize& memorySize)
{
    outputStream << memorySize.bytesCount << " B";
    return outputStream;
}

int main()
{
    // ✅ Явне створення
    MemorySize allocatedBuffer(52428800);  // 50 МБ у байтах
    std::cout << "Allocated buffer: " << allocatedBuffer << "\n";

    // ❌ Неявна конвертація заборонена
    // MemorySize firstBuffer = 1048576;           // ПОМИЛКА: explicit конструктор
    // MemorySize secondBuffer = 12.5;             // ПОМИЛКА: конструктор із double видалений

    // ✅ Явне створення дозволено
    MemorySize firstBuffer(1048576);               // 1 МБ
    MemorySize secondBuffer = MemorySize(2097152); // 2 МБ
    std::cout << "firstBuffer: " << firstBuffer << ", secondBuffer: " << secondBuffer << "\n";

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

    MemorySize emptyBuffer;
    if (!emptyBuffer)
    {
        std::cout << "Empty buffer evaluates to false\n";
    }

    // ✅ Явна конвертація у double (мегабайти)
    double megabytesValue = static_cast<double>(allocatedBuffer);
    std::cout << "Allocated buffer in megabytes: " << megabytesValue << " MB\n";

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

    // ✅ Порівняння між MemorySize працює
    if (firstBuffer == MemorySize(1048576))
    {
        std::cout << "firstBuffer equals 1048576 B (1 MB)\n";
    }

    return 0;
}