Механізм винятків: try, catch, throw та розкручування стеку

#include <iostream>
#include <cmath>

// Традиційний C-стилевий підхід: код помилки через повернення
int safeDivide(int a, int b, double& result)
{
    if (b == 0)
        return -1;  // Код помилки: ділення на нуль
    
    result = static_cast<double>(a) / b;
    return 0;  // Успіх
}

int safeSquareRoot(double value, double& result)
{
    if (value < 0)
        return -1;  // Код помилки: від'ємне значення
    
    result = std::sqrt(value);
    return 0;  // Успіх
}

int main()
{
    double result;
    
    // Потрібно перевіряти кожен виклик
    if (safeDivide(10, 0, result) != 0)
    {
        std::cout << "Помилка: ділення на нуль\n";
        return 1;
    }
    
    if (safeSquareRoot(-5, result) != 0)
    {
        std::cout << "Помилка: від'ємне значення під коренем\n";
        return 1;
    }
    
    std::cout << "Результат: " << result << "\n";
    return 0;
}

#include <iostream>

double safeDivide(int a, int b)
{
    if (b == 0)
        throw "Помилка: ділення на нуль";  // Викидаємо виняток типу const char*
    
    return static_cast<double>(a) / b;
}

int main()
{
    try
    {
        double result = safeDivide(10, 0);
        std::cout << "Результат: " << result << "\n";  // Не виконається
    }
    catch (const char* errorMessage)
    {
        std::cout << "Перехоплено виняток: " << errorMessage << "\n";
    }
    
    std::cout << "Програма продовжує виконання\n";
    return 0;
}

#include <iostream>
#include <string>

// Власний клас винятку
class DivisionByZeroError
{
private:
    int m_numerator;

public:
    DivisionByZeroError(int numerator) : m_numerator(numerator) {}

    std::string getMessage() const
    {
        return "Ділення " + std::to_string(m_numerator) + " на нуль неможливе";
    }
};

double safeDivide(int a, int b)
{
    if (b == 0)
        throw DivisionByZeroError(a);  // Викидаємо об'єкт класу
    
    return static_cast<double>(a) / b;
}

int main()
{
    try
    {
        std::cout << "Результат: " << safeDivide(10, 2) << "\n";
        std::cout << "Результат: " << safeDivide(15, 0) << "\n";  // Викине виняток
        std::cout << "Ця строка не виконається\n";
    }
    catch (const DivisionByZeroError& ex)
    {
        std::cout << "Перехоплено виняток: " << ex.getMessage() << "\n";
    }

    std::cout << "Програма продовжує роботу\n";
    return 0;
}

#include <iostream>
#include <string>

class DivisionByZeroError {};
class NegativeValueError {};

double complexCalculation(int a, int b)
{
    if (b == 0)
        throw DivisionByZeroError();
    
    double result = static_cast<double>(a) / b;
    
    if (result < 0)
        throw NegativeValueError();
    
    return result;
}

int main()
{
    try
    {
        double result = complexCalculation(-10, 2);  // Викине NegativeValueError
        std::cout << "Результат: " << result << "\n";
    }
    catch (const DivisionByZeroError&)
    {
        std::cout << "Помилка: спроба ділення на нуль\n";
    }
    catch (const NegativeValueError&)
    {
        std::cout << "Помилка: результат від'ємний\n";
    }
    catch (...)  // Універсальний catch для всіх інших типів
    {
        std::cout << "Невідома помилка\n";
    }

    return 0;
}

#include <iostream>

void level3()
{
    std::cout << "level3(): викидаємо виняток\n";
    throw 42;  // Немає try-catch — виняток йде до level2()
}

void level2()
{
    std::cout << "level2(): викликаємо level3()\n";
    level3();  // Немає try-catch — виняток йде до level1()
    std::cout << "level2(): ця строка не виконається\n";
}

void level1()
{
    std::cout << "level1(): викликаємо level2()\n";
    try
    {
        level2();
    }
    catch (int error)
    {
        std::cout << "level1(): перехоплено виняток з кодом " << error << "\n";
    }
    std::cout << "level1(): продовжуємо роботу\n";
}

int main()
{
    level1();
    std::cout << "main(): програма завершена\n";
    return 0;
}

#include <iostream>

class Resource
{
private:
    std::string m_name;

public:
    Resource(const std::string& name) : m_name(name)
    {
        std::cout << "  [Конструктор] " << m_name << " створено\n";
    }

    ~Resource()
    {
        std::cout << "  [Деструктор] " << m_name << " знищено\n";
    }
};

void functionC()
{
    Resource r3("Resource C");
    std::cout << "functionC(): викидаємо виняток\n";
    throw std::runtime_error("Помилка у functionC");
    std::cout << "functionC(): ця строка не виконається\n";
}

void functionB()
{
    Resource r2("Resource B");
    std::cout << "functionB(): викликаємо functionC()\n";
    functionC();
    std::cout << "functionB(): ця строка не виконається\n";
}

void functionA()
{
    Resource r1("Resource A");
    std::cout << "functionA(): викликаємо functionB()\n";
    
    try
    {
        functionB();
    }
    catch (const std::exception& ex)
    {
        std::cout << "functionA(): перехоплено виняток: " << ex.what() << "\n";
    }
    
    std::cout << "functionA(): продовжуємо роботу\n";
}

int main()
{
    std::cout << "=== Початок виконання ===\n";
    functionA();
    std::cout << "=== Завершення виконання ===\n";
    return 0;
}

#include <iostream>

void unsafeFunction()
{
    int* data = new int[1000];  // ❌ Небезпечно без RAII
    
    try
    {
        riskyOperation();  // Може викинути виняток
        delete[] data;  // Виконається лише якщо немає винятку
    }
    catch (...)
    {
        delete[] data;  // ⚠️ Потрібно дублювати звільнення
        throw;  // Перекидаємо виняток далі
    }
}

#include <iostream>

void lowLevelFunction()
{
    std::cout << "lowLevelFunction(): викидаємо виняток\n";
    throw std::runtime_error("Критична помилка на низькому рівні");
}

void middleLevelFunction()
{
    try
    {
        lowLevelFunction();
    }
    catch (const std::exception& ex)
    {
        std::cout << "middleLevelFunction(): частково обробляємо виняток\n";
        std::cout << "  Логування: " << ex.what() << "\n";
        
        // Перекидаємо той самий виняток далі
        throw;  // ← Без аргументів: перекидається оригінальний виняток
    }
}

void highLevelFunction()
{
    try
    {
        middleLevelFunction();
    }
    catch (const std::exception& ex)
    {
        std::cout << "highLevelFunction(): остаточна обробка\n";
        std::cout << "  Повідомлення користувачеві: операція не вдалася\n";
    }
}

int main()
{
    highLevelFunction();
    return 0;
}

#include <iostream>

class BaseException
{
public:
    virtual void printType() const { std::cout << "BaseException\n"; }
};

class DerivedException : public BaseException
{
public:
    void printType() const override { std::cout << "DerivedException\n"; }
};

void demonstrateSlicing()
{
    try
    {
        throw DerivedException();  // Викидаємо похідний тип
    }
    catch (const BaseException& ex)
    {
        ex.printType();  // Виведе "DerivedException" (правильно)
        
        // ❌ ПОГАНО: throw ex створить копію BaseException (зрізка!)
        // throw ex;
        
        // ✅ ДОБРЕ: throw без аргументів зберігає оригінальний тип
        throw;
    }
}

int main()
{
    try
    {
        demonstrateSlicing();
    }
    catch (const DerivedException&)
    {
        std::cout << "Перехоплено DerivedException\n";
    }
    catch (const BaseException&)
    {
        std::cout << "Перехоплено BaseException (зрізка сталась!)\n";
    }

    return 0;
}

#include <iostream>

class Resource
{
public:
    Resource() { std::cout << "[Конструктор] Resource створено\n"; }
    ~Resource() { std::cout << "[Деструктор] Resource знищено\n"; }
};

void throwUnhandledException()
{
    Resource res;
    throw std::runtime_error("Необроблений виняток");
}

int main()
{
    std::cout << "=== Початок програми ===\n";
    
    // ❌ Немає try-catch для перехоплення
    throwUnhandledException();
    
    std::cout << "=== Ця строка не виконається ===\n";
    return 0;
}

#include <iostream>
#include <exception>

void riskyOperation()
{
    throw std::runtime_error("Несподівана помилка");
}

int main()
{
    try
    {
        std::cout << "=== Початок програми ===\n";
        
        riskyOperation();
        
        std::cout << "=== Завершення програми ===\n";
    }
    catch (const std::exception& ex)
    {
        std::cerr << "ФАТАЛЬНА ПОМИЛКА: " << ex.what() << "\n";
        return 1;  // Код помилки для ОС
    }
    catch (...)
    {
        std::cerr << "НЕВІДОМА ФАТАЛЬНА ПОМИЛКА\n";
        return 2;
    }

    return 0;  // Успішне завершення
}

#include <iostream>

class DangerousResource
{
public:
    ~DangerousResource()
    {
        std::cout << "Деструктор: викидаємо виняток\n";
        throw std::runtime_error("Помилка у деструкторі");  // ❌ НЕБЕЗПЕЧНО!
    }
};

int main()
{
    try
    {
        DangerousResource res;
        throw std::runtime_error("Перший виняток");
    }
    catch (const std::exception& ex)
    {
        std::cout << "Перехоплено: " << ex.what() << "\n";
    }

    return 0;
}

void processData()
{
    int* data = new int[1000];
    
    validateInput();  // ❌ Якщо викине виняток, delete не виконається
    
    // Обробка data...
    
    delete[] data;  // Ця строка може не виконатись
}