throw 404;                           // викидання int
throw "File not found";              // викидання const char*
throw 3.14159;                       // викидання double

try {
    int* buffer = new int[computeSize()];     // може викинути std::bad_alloc
    array[index] = value;                     // може викинути int (код помилки)
    processData(buffer);                      // може викинути int (статус)
} catch (int errorCode) {
    // Що саме сталося? Який компонент згенерував цей int?
    // Як інтерпретувати значення errorCode? Це HTTP-код? POSIX errno? Індекс?
}

class exception {
public:
    virtual const char* what() const noexcept;
    // ... конструктори, деструктор
};

#include <iostream>
#include <exception>  // для std::exception
#include <new>        // для std::bad_alloc
#include <limits>     // для std::numeric_limits

int main() {
    try {
        // Спроба виділити гігантський масив (розмір близький до максимуму size_t)
        std::size_t hugeSize = std::numeric_limits<std::size_t>::max() / 2;
        int* ptr = new int[hugeSize];
        
        // Цей код ніколи не виконається
        delete[] ptr;
    }
    catch (const std::bad_alloc& e) {
        std::cerr << "Критична помилка виділення пам'яті!\n";
        std::cerr << "Технічна деталь: " << e.what() << '\n';
        return 1;
    }
    
    return 0;
}

#include <iostream>
#include <exception>
#include <string>
#include <stdexcept>

void riskyOperation(int mode) {
    if (mode == 1) {
        throw std::runtime_error("Мережевий сервіс недоступний");
    } else if (mode == 2) {
        throw std::out_of_range("Індекс виходить за межі масиву");
    } else if (mode == 3) {
        std::string s;
        s.resize(-1);  // генерує std::length_error
    }
}

int main() {
    for (int testCase = 1; testCase <= 3; ++testCase) {
        try {
            std::cout << "Виконання тест-кейсу #" << testCase << "...\n";
            riskyOperation(testCase);
            std::cout << "Успіх!\n";
        }
        catch (const std::exception& e) {
            // Цей універсальний обробник ловить ВСІ стандартні винятки
            std::cerr << "  [ERROR] Збій операції: " << e.what() << '\n';
        }
    }
    
    return 0;
}

try {
    throw std::out_of_range("Індекс 42 за межами діапазону [0, 10)");
}
catch (const std::exception& e) {
    std::cerr << "Спіймано std::exception: " << e.what() << '\n';
}
catch (const std::logic_error& e) {
    std::cerr << "Спіймано logic_error: " << e.what() << '\n';
}
catch (const std::out_of_range& e) {
    std::cerr << "Спіймано out_of_range: " << e.what() << '\n';
}

try {
    throw std::out_of_range("Індекс 42 за межами діапазону [0, 10)");
}
catch (const std::out_of_range& e) {
    // Найбільш специфічний обробник — перший
    std::cerr << "Спіймано out_of_range: " << e.what() << '\n';
    std::cerr << "  → Рекомендація: перевірте граничні умови циклу\n";
}
catch (const std::logic_error& e) {
    // Менш специфічний (батьківський клас out_of_range)
    std::cerr << "Спіймано logic_error: " << e.what() << '\n';
}
catch (const std::exception& e) {
    // Найменш специфічний (кореневий клас) — останній
    std::cerr << "Спіймано std::exception: " << e.what() << '\n';
}

#include <stdexcept>
#include <string>
#include <sstream>

class DivisionByZeroException : public std::runtime_error {
private:
    double m_dividend;  // ділене
    double m_divisor;   // дільник (завжди 0.0 для цього винятку)

public:
    DivisionByZeroException(double dividend, double divisor)
        : std::runtime_error(buildMessage(dividend, divisor)),
          m_dividend(dividend),
          m_divisor(divisor)
    {
    }

    // Геттери для доступу до контексту помилки
    double getDividend() const { return m_dividend; }
    double getDivisor() const { return m_divisor; }

private:
    // Допоміжна статична функція побудови повідомлення
    static std::string buildMessage(double dividend, double divisor) {
        std::ostringstream oss;
        oss << "Математична помилка: спроба ділення " 
            << dividend << " на " << divisor;
        return oss.str();
    }
};

#include <iostream>

double safeDivide(double a, double b) {
    if (b == 0.0) {
        throw DivisionByZeroException(a, b);
    }
    return a / b;
}

int main() {
    try {
        double x = 10.0, y = 0.0;
        double result = safeDivide(x, y);
        std::cout << "Результат: " << result << '\n';
    }
    catch (const DivisionByZeroException& e) {
        std::cerr << "КРИТИЧНА ПОМИЛКА: " << e.what() << '\n';
        std::cerr << "Контекст: ділене = " << e.getDividend() 
                  << ", дільник = " << e.getDivisor() << '\n';
        std::cerr << "Дія: перевірте вхідні дані користувача\n";
        return 1;
    }
    
    return 0;
}

#include <stdexcept>
#include <string>
#include <sstream>

// Базовий клас для всіх винятків IntArray
class ArrayException : public std::runtime_error {
public:
    explicit ArrayException(const std::string& message)
        : std::runtime_error(message)
    {
    }
};

// Виняток неприпустимого індексу (виходить за межі)
class ArrayIndexException : public ArrayException {
private:
    int m_requestedIndex;
    int m_arrayLength;

public:
    ArrayIndexException(int requestedIndex, int arrayLength)
        : ArrayException(buildMessage(requestedIndex, arrayLength)),
          m_requestedIndex(requestedIndex),
          m_arrayLength(arrayLength)
    {
    }

    int getRequestedIndex() const { return m_requestedIndex; }
    int getArrayLength() const { return m_arrayLength; }

private:
    static std::string buildMessage(int index, int length) {
        std::ostringstream oss;
        oss << "Індекс " << index << " виходить за межі масиву [0, " 
            << length << ")";
        return oss.str();
    }
};

// Виняток неприпустимого розміру масиву
class ArraySizeException : public ArrayException {
private:
    int m_requestedSize;

public:
    explicit ArraySizeException(int requestedSize)
        : ArrayException(buildMessage(requestedSize)),
          m_requestedSize(requestedSize)
    {
    }

    int getRequestedSize() const { return m_requestedSize; }

private:
    static std::string buildMessage(int size) {
        std::ostringstream oss;
        oss << "Неприпустимий розмір масиву: " << size 
            << " (має бути додатнім числом)";
        return oss.str();
    }
};

// Виняток збою виділення пам'яті для масиву
class ArrayAllocationException : public ArrayException {
private:
    std::size_t m_requestedBytes;

public:
    explicit ArrayAllocationException(std::size_t requestedBytes)
        : ArrayException(buildMessage(requestedBytes)),
          m_requestedBytes(requestedBytes)
    {
    }

    std::size_t getRequestedBytes() const { return m_requestedBytes; }

private:
    static std::string buildMessage(std::size_t bytes) {
        std::ostringstream oss;
        oss << "Не вдалося виділити " << bytes 
            << " байтів пам'яті для масиву";
        return oss.str();
    }
};

#include <iostream>

class IntArray {
private:
    int* m_data;
    int m_length;

public:
    explicit IntArray(int length) : m_data(nullptr), m_length(0) {
        if (length <= 0) {
            throw ArraySizeException(length);
        }

        try {
            m_data = new int[length];
            m_length = length;
        }
        catch (const std::bad_alloc&) {
            // Перехоплюємо стандартний виняток і перетворюємо на наш
            throw ArrayAllocationException(length * sizeof(int));
        }
    }

    ~IntArray() {
        delete[] m_data;
    }

    int& operator[](int index) {
        if (index < 0 || index >= m_length) {
            throw ArrayIndexException(index, m_length);
        }
        return m_data[index];
    }

    int getLength() const { return m_length; }
};

int main() {
    try {
        IntArray arr(-5);  // Спроба створити масив від'ємної довжини
        arr[100] = 42;     // Цей код не виконається
    }
    catch (const ArrayIndexException& e) {
        std::cerr << "Помилка індексації: " << e.what() << '\n';
        std::cerr << "  Запитаний індекс: " << e.getRequestedIndex() << '\n';
        std::cerr << "  Фактична довжина: " << e.getArrayLength() << '\n';
    }
    catch (const ArraySizeException& e) {
        std::cerr << "Помилка розміру: " << e.what() << '\n';
        std::cerr << "  Некоректний розмір: " << e.getRequestedSize() << '\n';
    }
    catch (const ArrayAllocationException& e) {
        std::cerr << "Критична помилка пам'яті: " << e.what() << '\n';
        std::cerr << "  Запитаний обсяг: " << e.getRequestedBytes() << " байт\n";
    }
    catch (const ArrayException& e) {
        // Універсальний обробник для всіх інших помилок IntArray
        std::cerr << "Загальна помилка масиву: " << e.what() << '\n';
    }
    catch (const std::exception& e) {
        // Фінальний страхувальний обробник
        std::cerr << "Непередбачена помилка: " << e.what() << '\n';
    }
    
    return 0;
}

catch (...) {
    // Цей блок спіймає будь-який виняток
}

#include <iostream>

void unpredictableFunction(int mode) {
    if (mode == 1) throw 42;                         // int
    if (mode == 2) throw "Текстова помилка";         // const char*
    if (mode == 3) throw std::runtime_error("Збій"); // std::exception
    if (mode == 4) throw 3.14159;                    // double
}

int main() {
    for (int i = 1; i <= 4; ++i) {
        try {
            unpredictableFunction(i);
        }
        catch (const std::exception& e) {
            std::cerr << "Стандартний виняток: " << e.what() << '\n';
        }
        catch (...) {
            std::cerr << "Невідомий виняток невизначеного типу!\n";
        }
    }
    
    return 0;
}

int main() {
    try {
        runApplication();  // Основна логіка програми
    }
    catch (const std::exception& e) {
        std::cerr << "Критична помилка: " << e.what() << '\n';
        logErrorToFile(e.what());
        return 1;
    }
    catch (...) {
        std::cerr << "Фатальна помилка невідомого типу!\n";
        std::cerr << "Програму буде завершено аварійно.\n";
        return 2;
    }
    
    return 0;
}

void experimentalAlgorithm() {
    try {
        // Код, що тестується
        complexCalculation();
    }
    catch (const std::exception& e) {
        std::cerr << "[DEBUG] Стандартний виняток: " << e.what() << '\n';
        throw;  // Повторно генеруємо для подальшого аналізу
    }
    catch (...) {
        std::cerr << "[DEBUG] Невідомий виняток! Точка збою зафіксована.\n";
        throw;  // Критично важливо: не ковтаємо виняток!
    }
}

std::terminate();  // Визначена у заголовку <exception>

#include <iostream>
#include <exception>

class Resource {
public:
    Resource() { 
        std::cout << "Ресурс створено\n"; 
    }
    
    ~Resource() { 
        std::cout << "Ресурс знищено (деструктор викликано)\n"; 
    }
};

void riskyFunction() {
    Resource res;
    throw std::runtime_error("Критична помилка!");
    // Деструктор res викличеться під час stack unwinding
}

int main() {
    riskyFunction();  // Виняток не перехоплюється!
    // std::terminate() буде викликано автоматично
    return 0;
}

#include <iostream>
#include <exception>
#include <ctime>
#include <fstream>

// Власний обробник аварійного завершення
void customTerminateHandler() {
    std::cerr << "\n========== КРИТИЧНА ПОМИЛКА ==========\n";
    std::cerr << "Програму буде завершено через необроблений виняток.\n";
    
    // Логування у файл
    std::ofstream logFile("crash_report.txt", std::ios::app);
    if (logFile.is_open()) {
        std::time_t now = std::time(nullptr);
        logFile << "Аварія зафіксована: " << std::ctime(&now);
        logFile << "Необроблений виняток досяг std::terminate\n";
        logFile << "========================================\n\n";
        logFile.close();
        std::cerr << "Звіт збережено у crash_report.txt\n";
    }
    
    std::cerr << "======================================\n\n";
    
    // Викликаємо стандартний abort для припинення процесу
    std::abort();
}

void faultyFunction() {
    throw std::runtime_error("Необроблена помилка!");
}

int main() {
    // Встановлюємо власний обробник на початку програми
    std::set_terminate(customTerminateHandler);
    
    std::cout << "Програма запущена...\n";
    faultyFunction();  // Виняток не буде спійманий
    
    return 0;
}

#include <iostream>
#include <exception>
#include <stdexcept>
#include <fstream>

void advancedTerminateHandler() {
    std::cerr << "\n[TERMINATE HANDLER] Спроба отримати інформацію про виняток...\n";
    
    std::exception_ptr currentException = std::current_exception();
    
    if (currentException) {
        try {
            std::rethrow_exception(currentException);
        }
        catch (const std::exception& e) {
            std::cerr << "[EXCEPTION] Тип: std::exception\n";
            std::cerr << "[EXCEPTION] Повідомлення: " << e.what() << '\n';
            
            // Логування у файл
            std::ofstream log("exception_dump.txt");
            log << "Uncaught exception: " << e.what() << '\n';
            log.close();
        }
        catch (...) {
            std::cerr << "[EXCEPTION] Невідомий тип винятку\n";
        }
    } else {
        std::cerr << "[TERMINATE HANDLER] Не вдалося отримати інформацію про виняток\n";
    }
    
    std::abort();
}

int main() {
    std::set_terminate(advancedTerminateHandler);
    
    throw std::runtime_error("Неспіймана критична помилка конфігурації!");
    
    return 0;
}

class DatabaseRepository {
public:
    User findUserById(int userId) {
        if (userId <= 0) {
            throw std::invalid_argument("ID користувача має бути додатнім");
        }
        
        try {
            // Виконання SQL-запиту через бібліотеку БД
            return executeQuery(userId);
        }
        catch (const DatabaseConnectionError& e) {
            // Логуємо технічні деталі
            logError("DB connection failed", e.getConnectionString());
            
            // Перетворюємо технічний виняток на бізнес-виняток
            throw UserNotFoundException(userId, "База даних недоступна");
        }
    }
};

class UserService {
private:
    DatabaseRepository m_repo;

public:
    void displayUserProfile(int userId) {
        try {
            User user = m_repo.findUserById(userId);
            std::cout << "Користувач: " << user.getName() << '\n';
        }
        catch (const UserNotFoundException& e) {
            // Бізнес-логіка обробки: повідомлення користувачу
            std::cerr << "Профіль не знайдено: " << e.what() << '\n';
            std::cerr << "Спробуйте інший ID або зверніться до підтримки.\n";
        }
        catch (const std::invalid_argument& e) {
            // Обробка логічної помилки програміста
            std::cerr << "Помилка валідації вхідних даних: " << e.what() << '\n';
        }
    }
};

int main() {
    try {
        UserService service;
        service.displayUserProfile(getUserInputId());
    }
    catch (const std::exception& e) {
        // Універсальний обробник для необроблених винятків
        std::cerr << "Системна помилка: " << e.what() << '\n';
        std::cerr << "Програма буде завершена.\n";
        return 1;
    }
    catch (...) {
        // Страхувальний catch-all
        std::cerr << "Критична невідома помилка!\n";
        return 2;
    }
    
    return 0;
}

#include <fstream>
#include <stdexcept>
#include <string>

class SafeFileWriter {
private:
    std::ofstream m_file;
    std::string m_filename;
    bool m_committed;  // Прапорець успішного завершення запису

public:
    explicit SafeFileWriter(const std::string& filename)
        : m_filename(filename), m_committed(false)
    {
        m_file.open(filename);
        if (!m_file.is_open()) {
            throw std::runtime_error("Не вдалося відкрити файл: " + filename);
        }
    }

    void write(const std::string& data) {
        if (!m_file.good()) {
            throw std::runtime_error("Файл у неробочому стані");
        }
        m_file << data;
        if (m_file.fail()) {
            throw std::runtime_error("Помилка запису у файл");
        }
    }

    void commit() {
        m_file.flush();
        m_committed = true;
    }

    ~SafeFileWriter() {
        if (m_file.is_open()) {
            m_file.close();
        }
        
        // Якщо виняток перервав операцію до commit(), видаляємо частковий файл
        if (!m_committed) {
            std::remove(m_filename.c_str());
        }
    }
};

void processData() {
    SafeFileWriter writer("output.txt");
    
    writer.write("Перший рядок\n");
    writer.write("Другий рядок\n");
    
    // Якщо тут станеться виняток, деструктор видалить частковий файл
    riskyOperation();
    
    writer.write("Третій рядок\n");
    writer.commit();  // Підтвердження успішного завершення
}