// Нижній рівень: Repository (доступ до бази даних)
User DatabaseRepository::findUserById(int userId) {
    try {
        return executeQuery(userId);  // SQL-запит може згенерувати виняток
    }
    catch (const DatabaseException& e) {
        // Логуємо технічну інформацію про збій БД
        logger.error("Database query failed", e.getSqlCode(), e.getQuery());
        
        // ❓ Як повідомити верхній рівень про помилку?
        // Ми не можемо просто "проковтнути" виняток — це приховає проблему
        // Ми не можемо повернути User — об'єкт не існує
    }
}

// Середній рівень: Service (бізнес-логіка)
void UserService::displayProfile(int userId) {
    try {
        User user = repository.findUserById(userId);
        console.print(user.getName());
    }
    catch (const DatabaseException& e) {
        // Тут ми хочемо відобразити користувачеві повідомлення:
        // "Сервіс тимчасово недоступний, спробуйте пізніше"
    }
}

catch (const DatabaseException& e) {
    logger.error("Database query failed");
    throw std::runtime_error("Query failed");  // Втрачено всю діагностичну інформацію!
}

catch (const DatabaseException& e) {
    logger.error("Database query failed");
    throw e;  // ⚠️ НЕБЕЗПЕКА: відбудеться зрізка об'єкта!
}

catch (const DatabaseException& e) {
    logger.error("Database query failed", e.getSqlCode());
    throw;  // ✅ Повторна генерація ОРИГІНАЛЬНОГО винятку без змін
}

class BaseException : public std::runtime_error {
public:
    explicit BaseException(const std::string& msg) 
        : std::runtime_error(msg) {}
    
    virtual std::string getCategory() const { return "Base"; }
};

class NetworkException : public BaseException {
private:
    int m_errorCode;

public:
    NetworkException(const std::string& msg, int code)
        : BaseException(msg), m_errorCode(code) {}
    
    std::string getCategory() const override { return "Network"; }
    int getErrorCode() const { return m_errorCode; }
};

void intermediateFunction() {
    try {
        throw NetworkException("Connection timeout", 504);
    }
    catch (const BaseException& e) {
        std::cerr << "[INTERMEDIATE] Категорія: " << e.getCategory() << '\n';
        throw;  // ✅ Повторна генерація ОРИГІНАЛЬНОГО NetworkException
    }
}

int main() {
    try {
        intermediateFunction();
    }
    catch (const NetworkException& e) {
        // ✅ Цей обробник СПІЙМАЄ виняток!
        std::cerr << "[MAIN] Спіймано NetworkException\n";
        std::cerr << "  Категорія: " << e.getCategory() << '\n';
        std::cerr << "  Код помилки: " << e.getErrorCode() << '\n';
    }
    catch (const BaseException& e) {
        std::cerr << "[MAIN] Спіймано BaseException\n";
    }
    
    return 0;
}

void intermediateFunction() {
    try {
        throw NetworkException("Connection timeout", 504);
    }
    catch (const BaseException& e) {
        std::cerr << "[INTERMEDIATE] Категорія: " << e.getCategory() << '\n';
        throw e;  // ❌ НЕБЕЗПЕКА: генерується КОПІЯ як BaseException!
    }
}

int main() {
    try {
        intermediateFunction();
    }
    catch (const NetworkException& e) {
        // ❌ Цей обробник НІКОЛИ не спрацює!
        std::cerr << "[MAIN] Спіймано NetworkException\n";
    }
    catch (const BaseException& e) {
        // ✅ Спрацює цей обробник
        std::cerr << "[MAIN] Спіймано BaseException\n";
        std::cerr << "  Категорія: " << e.getCategory() << '\n';
        
        // ❌ Не можемо викликати getErrorCode() — метод не існує в BaseException
    }
    
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <fstream>
#include <ctime>

class ErrorLogger {
public:
    void logException(const std::exception& e) {
        std::ofstream log("errors.log", std::ios::app);
        std::time_t now = std::time(nullptr);
        log << std::ctime(&now) << "  ERROR: " << e.what() << '\n';
        log.close();
    }
};

ErrorLogger g_logger;

void riskyDatabaseOperation() {
    // Симуляція помилки БД
    throw std::runtime_error("SQL syntax error in SELECT query");
}

void dataAccessLayer() {
    try {
        riskyDatabaseOperation();
    }
    catch (const std::exception& e) {
        // Логуємо помилку для системи моніторингу
        g_logger.logException(e);
        std::cerr << "[DATA LAYER] Помилка зафіксована в логах\n";
        
        // Повторно генеруємо для обробки верхнім рівнем
        throw;
    }
}

void businessLogicLayer() {
    try {
        dataAccessLayer();
    }
    catch (const std::exception& e) {
        std::cerr << "[BUSINESS LAYER] Обробка помилки: " << e.what() << '\n';
        std::cerr << "  → Повернення користувачеві повідомлення про тимчасову недоступність\n";
    }
}

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

Fri Oct  9 14:23:11 2026
  ERROR: SQL syntax error in SELECT query

void smartMiddleware(bool canRecover) {
    try {
        riskyOperation();
    }
    catch (const RecoverableException& e) {
        if (canRecover) {
            std::cerr << "Спроба автоматичного відновлення...\n";
            attemptRecovery();
            // Виняток оброблено, не генеруємо далі
        } else {
            std::cerr << "Автоматичне відновлення неможливе\n";
            throw;  // Передаємо на верхній рівень
        }
    }
    catch (const CriticalException& e) {
        // Критичні помилки завжди передаємо вище
        std::cerr << "Критична помилка: " << e.what() << '\n';
        throw;
    }
}

class ContextualException : public std::runtime_error {
private:
    std::string m_operationName;
    std::string m_originalError;

public:
    ContextualException(const std::string& operation, 
                         const std::exception& original)
        : std::runtime_error(buildMessage(operation, original)),
          m_operationName(operation),
          m_originalError(original.what())
    {
    }

    std::string getOperation() const { return m_operationName; }
    std::string getOriginalError() const { return m_originalError; }

private:
    static std::string buildMessage(const std::string& op, 
                                      const std::exception& orig) {
        return "Операція '" + op + "' зазнала невдачі: " + orig.what();
    }
};

void processUserData(int userId) {
    try {
        fetchDataFromDatabase(userId);
    }
    catch (const DatabaseException& e) {
        // Обгортаємо технічний виняток у бізнес-контекст
        throw ContextualException("ProcessUserData", e);
    }
}

int main() {
    try {
        processUserData(12345);
    }
    catch (const ContextualException& e) {
        std::cerr << "Контекстна помилка:\n";
        std::cerr << "  Операція: " << e.getOperation() << '\n';
        std::cerr << "  Оригінальна помилка: " << e.getOriginalError() << '\n';
    }
    
    return 0;
}

class DatabaseConnection {
public:
    explicit DatabaseConnection(const std::string& connectionString) {
        if (connectionString.empty()) {
            throw std::invalid_argument("Connection string cannot be empty");
        }
        // Підключення до БД...
    }
};

class UserRepository {
private:
    DatabaseConnection m_connection;

public:
    UserRepository(const std::string& connStr)
        : m_connection(connStr)  // ❓ Що, якщо тут згенерується виняток?
    {
        // Тіло конструктора виконується ПІСЛЯ ініціалізації m_connection
        // Стандартний try тут не допоможе!
    }
};

ClassName::ClassName(параметри)
try
    : memberInitializerList
{
    // Тіло конструктора
}
catch (ExceptionType& e) {
    // Обробка винятків зі списку ініціалізації та тіла конструктора
}

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

class DatabaseConnection {
public:
    explicit DatabaseConnection(const std::string& connectionString) {
        if (connectionString.empty()) {
            throw std::invalid_argument("Connection string cannot be empty");
        }
        std::cout << "✓ DatabaseConnection успішно створено\n";
    }
};

class UserRepository {
private:
    DatabaseConnection m_connection;
    int m_cacheSize;

public:
    UserRepository(const std::string& connStr, int cacheSize)
    try
        : m_connection(connStr),  // Може згенерувати std::invalid_argument
          m_cacheSize(cacheSize)
    {
        std::cout << "✓ UserRepository тіло конструктора виконано\n";
        
        if (cacheSize <= 0) {
            throw std::logic_error("Cache size must be positive");
        }
    }
    catch (const std::invalid_argument& e) {
        std::cerr << "[UserRepository CONSTRUCTOR] Помилка ініціалізації:\n";
        std::cerr << "  " << e.what() << '\n';
        std::cerr << "  → Неможливо створити репозиторій без підключення до БД\n";
        
        // Явно не генеруємо виняток, тому відбудеться неявна повторна генерація
    }
    catch (const std::logic_error& e) {
        std::cerr << "[UserRepository CONSTRUCTOR] Логічна помилка:\n";
        std::cerr << "  " << e.what() << '\n';
        
        // Явно не генеруємо виняток, тому відбудеться неявна повторна генерація
    }
    catch (...) {
        std::cerr << "[UserRepository CONSTRUCTOR] Непередбачена помилка!\n";
        throw;  // Явне повторне генерування (еквівалентно неявному)
    }
};

int main() {
    std::cout << "=== Тест 1: Порожній рядок підключення ===\n";
    try {
        UserRepository repo1("", 100);
    }
    catch (const std::exception& e) {
        std::cerr << "[MAIN] Спійманий виняток: " << e.what() << "\n\n";
    }

    std::cout << "=== Тест 2: Некоректний розмір кешу ===\n";
    try {
        UserRepository repo2("Server=localhost;", -5);
    }
    catch (const std::exception& e) {
        std::cerr << "[MAIN] Спійманий виняток: " << e.what() << "\n\n";
    }

    std::cout << "=== Тест 3: Коректні параметри ===\n";
    try {
        UserRepository repo3("Server=localhost;", 100);
        std::cout << "✓ UserRepository успішно створено\n";
    }
    catch (const std::exception& e) {
        std::cerr << "[MAIN] Спійманий виняток: " << e.what() << '\n';
    }

    return 0;
}

#include <iostream>
#include <stdexcept>

class Component {
public:
    Component() {
        throw std::runtime_error("Component initialization failed");
    }
};

class System {
private:
    Component m_component;

public:
    System()
    try
        : m_component()  // Тут згенерується виняток
    {
        std::cout << "Це повідомлення ніколи не з'явиться\n";
    }
    catch (const std::exception& e) {
        std::cerr << "[System CATCH] Перехоплено: " << e.what() << '\n';
        std::cerr << "[System CATCH] Логуємо помилку...\n";
        
        // НЕ пишемо тут throw; — але виняток все одно повторно згенерується!
    }
    // Неявний throw; додається компілятором тут
};

int main() {
    try {
        System sys;
        std::cout << "System створено — це повідомлення не з'явиться\n";
    }
    catch (const std::exception& e) {
        std::cerr << "[MAIN] Спійманий виняток: " << e.what() << '\n';
    }
    
    return 0;
}

System()
try
    : m_component()
{
}
catch (const std::exception& e) {
    std::cerr << "[System] Оригінальна помилка: " << e.what() << '\n';
    
    // Генеруємо НОВИЙ виняток замість оригінального
    throw std::runtime_error("System initialization failed due to Component error");
}
// Компілятор НЕ додає throw; тут, оскільки ми вже явно згенерували виняток

class DangerousClass {
private:
    int* m_data;
    std::string m_name;

public:
    DangerousClass(int size)
    try
        : m_data(new int[size]),
          m_name("DangerousObject")
    {
        if (size <= 0) {
            throw std::invalid_argument("Size must be positive");
        }
    }
    catch (const std::exception& e) {
        std::cerr << "Помилка: " << e.what() << '\n';
        
        // ❌ НЕБЕЗПЕЧНО: Спроба звернутися до m_data
        // delete[] m_data;  // UB! Об'єкт не існує, m_data у невизначеному стані
        
        // ❌ НЕБЕЗПЕЧНО: Спроба прочитати m_name
        // std::cerr << "Ім'я: " << m_name << '\n';  // UB!
        
        throw;
    }
};

#include <memory>
#include <vector>
#include <string>

class SafeClass {
private:
    std::unique_ptr<int[]> m_data;  // ✅ Автоматичне звільнення через RAII
    std::string m_name;              // ✅ std::string сам керує пам'яттю

public:
    SafeClass(int size)
    try
        : m_data(std::make_unique<int[]>(size)),
          m_name("SafeObject")
    {
        if (size <= 0) {
            throw std::invalid_argument("Size must be positive");
        }
    }
    catch (const std::exception& e) {
        std::cerr << "Помилка ініціалізації: " << e.what() << '\n';
        
        // ✅ БЕЗПЕЧНО: Нічого не робимо — деструктори полів викличуться автоматично
        // m_data автоматично звільнить пам'ять через ~unique_ptr
        // m_name автоматично звільнить рядок через ~string
        
        throw;  // Повторно генеруємо виняток
    }
};

void regularFunction()
try {
    // Тіло функції
    riskyOperation();
}
catch (const std::exception& e) {
    std::cerr << "Помилка: " << e.what() << '\n';
    // Тут повторне генерування НЕ є обов'язковим (на відміну від конструкторів)
}

void regularFunction() {
    try {
        riskyOperation();
    }
    catch (const std::exception& e) {
        std::cerr << "Помилка: " << e.what() << '\n';
    }
}