void transferMoney(Account& from, Account& to, double amount) {
    from.withdraw(amount);  // Списуємо з рахунку from
    to.deposit(amount);     // ❌ ЩО, ЯКЩО ТУТ ЗГЕНЕРУЄТЬСЯ ВИНЯТОК?
}

class UnsafeArray {
private:
    int* m_data;
    int m_size;

public:
    void resize(int newSize) {
        // ❌ НЕБЕЗПЕЧНО: якщо new викине std::bad_alloc, 
        // старі дані вже знищені, але нові не виділені
        delete[] m_data;
        m_data = new int[newSize];  // Може згенерувати виняток!
        m_size = newSize;
    }
};

class BasicSafeArray {
private:
    int* m_data;
    int m_size;

public:
    void resize(int newSize) {
        int* newData = new int[newSize];  // Виділяємо НОВУ пам'ять спочатку
        
        // Копіюємо стару пам'ять у нову (може згенерувати виняток, якщо int має нетривіальний конструктор)
        int copySize = (newSize < m_size) ? newSize : m_size;
        for (int i = 0; i < copySize; ++i) {
            newData[i] = m_data[i];
        }
        
        // Тільки ПІСЛЯ успішного виділення та копіювання звільняємо стару пам'ять
        delete[] m_data;
        m_data = newData;
        m_size = newSize;
    }
};

class StrongSafeArray {
private:
    int* m_data;
    int m_size;

public:
    void resize(int newSize) {
        // Створюємо ТИМЧАСОВИЙ об'єкт з новим розміром
        StrongSafeArray temp(newSize);
        
        // Копіюємо дані у тимчасовий об'єкт
        int copySize = (newSize < m_size) ? newSize : m_size;
        for (int i = 0; i < copySize; ++i) {
            temp.m_data[i] = m_data[i];  // Якщо тут виняток — наш об'єкт не змінився!
        }
        
        // ТІЛЬКИ якщо ВСЕ успішно — обмінюємо стани через swap (no-throw)
        swap(temp);  // Не генерує винятків
        
        // temp знищується, звільняючи СТАРУ пам'ять через деструктор
    }
    
private:
    void swap(StrongSafeArray& other) noexcept {
        std::swap(m_data, other.m_data);
        std::swap(m_size, other.m_size);
    }
};

class NoThrowSwappable {
private:
    int* m_data;
    int m_size;

public:
    // Обмін станів НІКОЛИ не генерує винятків
    void swap(NoThrowSwappable& other) noexcept {
        std::swap(m_data, other.m_data);  // Обмін покажчиків — тривіальна операція
        std::swap(m_size, other.m_size);  // Обмін int — тривіальна операція
    }
    
    // Move-конструктор не генерує винятків
    NoThrowSwappable(NoThrowSwappable&& other) noexcept
        : m_data(other.m_data), m_size(other.m_size)
    {
        other.m_data = nullptr;
        other.m_size = 0;
    }
};

class NaiveString {
private:
    char* m_data;
    std::size_t m_length;

public:
    // ❌ ПРОБЛЕМАТИЧНА реалізація operator=
    NaiveString& operator=(const NaiveString& other) {
        if (this == &other) return *this;  // Перевірка самоприсвоювання
        
        // Видаляємо стару пам'ять
        delete[] m_data;
        
        // Виділяємо нову пам'ять
        m_length = other.m_length;
        m_data = new char[m_length + 1];  // ❌ ЩО, ЯКЩО ТУТ ЗГЕНЕРУЄТЬСЯ std::bad_alloc?
        
        // Копіюємо дані
        std::strcpy(m_data, other.m_data);
        
        return *this;
    }
};

NaiveString& operator=(const NaiveString& other) {
    if (this == &other) return *this;
    
    // Виділяємо НОВУ пам'ять ПЕРЕД видаленням старої
    char* newData = new char[other.m_length + 1];  // Може згенерувати виняток
    std::strcpy(newData, other.m_data);
    
    // Тільки після успішного виділення видаляємо стару пам'ять
    delete[] m_data;
    m_data = newData;
    m_length = other.m_length;
    
    return *this;
}

class SafeString {
private:
    char* m_data;
    std::size_t m_length;

public:
    // Конструктор копіювання (може згенерувати виняток)
    SafeString(const SafeString& other)
        : m_length(other.m_length),
          m_data(new char[m_length + 1])
    {
        std::strcpy(m_data, other.m_data);
    }
    
    // No-throw swap
    void swap(SafeString& other) noexcept {
        std::swap(m_data, other.m_data);
        std::swap(m_length, other.m_length);
    }
    
    // Оператор присвоювання через Copy-and-Swap (СИЛЬНА ГАРАНТІЯ)
    SafeString& operator=(const SafeString& other) {
        // Створюємо ТИМЧАСОВУ копію через конструктор копіювання
        // Якщо тут згенерується виняток — наш об'єкт (*this) не змінився!
        SafeString temp(other);
        
        // Обмінюємо стан з тимчасовою копією (НІКОЛИ не генерує винятків)
        swap(temp);
        
        // temp знищується, звільняючи СТАРУ пам'ять через деструктор
        return *this;
    }
    
    // Альтернативний елегантний синтаксис (передача за значенням)
    SafeString& operator=(SafeString other) {  // other — вже копія!
        swap(other);  // Обмінюємо з копією
        return *this;
    }
    
    ~SafeString() {
        delete[] m_data;
    }
};

class Resource {
public:
    ~Resource() {
        // Припустимо, тут генерується виняток
        throw std::runtime_error("Cleanup failed");
    }
};

void dangerousFunction() {
    Resource res1;
    Resource res2;
    
    throw std::logic_error("Operation failed");  // Перший виняток
    
    // При розкручуванні стеку деструктори ~Resource() викличуться автоматично
}

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

class SafeFileHandle {
private:
    std::ofstream m_file;
    std::string m_filename;

public:
    explicit SafeFileHandle(const std::string& filename)
        : m_filename(filename)
    {
        m_file.open(filename);
        if (!m_file.is_open()) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
    }
    
    ~SafeFileHandle() noexcept {  // Явно позначаємо noexcept
        try {
            if (m_file.is_open()) {
                m_file.close();
                
                // Перевіряємо, чи закриття пройшло успішно
                if (m_file.fail()) {
                    // ❌ НЕ генеруємо виняток! Логуємо помилку
                    std::cerr << "[ERROR] Failed to close file: " 
                              << m_filename << '\n';
                }
            }
        }
        catch (const std::exception& e) {
            // Ловимо будь-які винятки та логуємо
            std::cerr << "[ERROR] Exception in destructor: " 
                      << e.what() << '\n';
            // НЕ повторно генеруємо виняток!
        }
        catch (...) {
            std::cerr << "[ERROR] Unknown exception in destructor\n";
        }
    }
    
    void write(const std::string& data) {
        m_file << data;
        if (m_file.fail()) {
            throw std::runtime_error("Failed to write to file");
        }
    }
};

class ExplicitCleanupFile {
private:
    std::ofstream m_file;
    bool m_closed;

public:
    explicit ExplicitCleanupFile(const std::string& filename)
        : m_closed(false)
    {
        m_file.open(filename);
        if (!m_file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }
    
    // Явний метод закриття (МОЖЕ генерувати винятки)
    void close() {
        if (m_closed) return;
        
        m_file.close();
        m_closed = true;
        
        if (m_file.fail()) {
            throw std::runtime_error("Failed to close file properly");
        }
    }
    
    // Деструктор робить "best effort" без винятків
    ~ExplicitCleanupFile() noexcept {
        if (!m_closed) {
            try {
                m_file.close();
            }
            catch (...) {
                // Мовчазно ігноруємо помилки у деструкторі
            }
        }
    }
};

// Використання:
void processFile() {
    ExplicitCleanupFile file("data.txt");
    
    file.write("some data");
    
    // Явно закриваємо файл і обробляємо можливий виняток
    try {
        file.close();
    }
    catch (const std::exception& e) {
        std::cerr << "Failed to properly close file: " << e.what() << '\n';
        // Тут можна прийняти рішення: повторити, відкинути дані тощо
    }
    
    // Якщо забули викликати close(), деструктор спробує закрити файл без винятків
}

// Специфікатор noexcept після сигнатури функції
void safeFunction() noexcept {
    // Ця функція обіцяє не генерувати винятків
}

// Еквівалентно (C++17 і новіші):
void safeFunction() noexcept(true) {
    // true = не генерує винятків
}

// Явне позначення, що функція МОЖЕ генерувати винятки (за замовчуванням):
void riskyFunction() noexcept(false) {
    // false = може генерувати винятки (зайве, бо це дефолт)
}

std::vector<MyClass> vec;
vec.reserve(10);

for (int i = 0; i < 15; ++i) {
    vec.push_back(MyClass(i));  // На 11-му елементі потрібна реаллокація
}

#include <iostream>
#include <vector>

class WithoutNoexcept {
public:
    WithoutNoexcept() { std::cout << "  Конструктор\n"; }
    
    // Move-конструктор БЕЗ noexcept
    WithoutNoexcept(WithoutNoexcept&& other) {
        std::cout << "  Move-конструктор (НЕ noexcept)\n";
    }
    
    // Конструктор копіювання
    WithoutNoexcept(const WithoutNoexcept& other) {
        std::cout << "  Конструктор копіювання\n";
    }
};

class WithNoexcept {
public:
    WithNoexcept() { std::cout << "  Конструктор\n"; }
    
    // Move-конструктор З noexcept
    WithNoexcept(WithNoexcept&& other) noexcept {
        std::cout << "  Move-конструктор (noexcept)\n";
    }
    
    // Конструктор копіювання
    WithNoexcept(const WithNoexcept& other) {
        std::cout << "  Конструктор копіювання\n";
    }
};

int main() {
    std::cout << "=== Без noexcept ===\n";
    {
        std::vector<WithoutNoexcept> vec;
        vec.reserve(2);
        vec.push_back(WithoutNoexcept());
        vec.push_back(WithoutNoexcept());
        std::cout << "Реалокація:\n";
        vec.push_back(WithoutNoexcept());  // Тригерить реалокацію
    }
    
    std::cout << "\n=== З noexcept ===\n";
    {
        std::vector<WithNoexcept> vec;
        vec.reserve(2);
        vec.push_back(WithNoexcept());
        vec.push_back(WithNoexcept());
        std::cout << "Реалокація:\n";
        vec.push_back(WithNoexcept());  // Тригерить реалокацію
    }
    
    return 0;
}

template <typename T>
void smartSwap(T& a, T& b) noexcept(noexcept(std::swap(a, b))) {
    //                      ^^^^^^^ оператор noexcept (перевіряє, чи виклик не генерує винятків)
    //      ^^^^^^^ специфікатор noexcept (позначає функцію)
    
    std::swap(a, b);
}

#include <type_traits>

void noThrowFunc() noexcept {}
void throwFunc() {}

static_assert(noexcept(noThrowFunc()), 
              "noThrowFunc must be noexcept");

static_assert(!noexcept(throwFunc()), 
              "throwFunc may throw");

// Для типів:
static_assert(std::is_nothrow_move_constructible<std::string>::value,
              "std::string should have noexcept move constructor");