Безопасность исключений и RAII в C++

void riskyFunction() {
    Resource* resource = new Resource();
    // что-то делаем
    if (error_condition)
        throw std::runtime_error("Oops!");
    // что-то ещё делаем
    delete resource; // эта строка никогда не выполнится при исключении
}

void basicGuarantee() {
    std::vector<int> data;
    try {
        data.push_back(42);  // Может выбросить исключение при нехватке памяти
        // Если выбросится исключение, программа будет в валидном состоянии,
        // но data может остаться пустым вектором или содержать 42
    } catch(const std::exception& e) {
        // Обработка ошибки
    }
}

void strongGuarantee() {
    std::vector<int> original = {1, 2, 3};
    std::vector<int> data = original;
    
    try {
        // Создаём временную копию, модифицируем её
        std::vector<int> temp = data;
        temp.push_back(42);
        temp.push_back(17);
        
        // Если всё успешно, замещаем оригинал (не может выбросить исключение)
        data.swap(temp);
    } catch(const std::exception& e) {
        // data остаётся неизменным при любых исключениях
    }
}

void nothrowGuarantee() noexcept {
    // Этот код НИКОГДА не должен выбрасывать исключений
    // Иначе программа аварийно завершится через std::terminate()
}

class Tricky {
private:
    Resource* res1;
    Resource* res2;
public:
    Tricky() : res1(new Resource()) {
        // Если здесь выбрасывается исключение, 
        // деструктор для res1 НЕ будет вызван автоматически!
        res2 = new Resource();  
    }
    
    ~Tricky() {
        delete res1;
        delete res2;
    }
};

try {
    // Код, который может выбросить исключение A
} catch (const ExceptionA& a) {
    try {
        // Код обработки исключения, который может выбросить исключение B
    } catch (const ExceptionB& b) {
        // Обработка вложенного исключения
    }
}

class FileHandler {
private:
    FILE* file;
public:
    FileHandler(const char* filename) {
        file = fopen(filename, "r");
        if (!file) throw std::runtime_error("Failed to open file");
    }
    
    ~FileHandler() {
        if (file) {
            fclose(file);
        }
    }
    
    // Методы для работы с файлом
};

void processFile() {
    FileHandler file("data.txt"); // Ресурс захвачен
    
    // Даже если здесь произойдёт исключение,
    // деструктор будет вызван автоматически!
    processData(file);
    
} // file.~FileHandler() вызывается здесь, ресурс освобожден

void oldSchool() {
    FILE* file = fopen("data.txt", "r");
    if (!file) return;
    
    // Код может содержать множество выходов из функции
    if (error_condition1) {
        fclose(file); // Повторение кода
        return;
    }
    
    // Или выбросить исключение
    if (error_condition2) {
        fclose(file); // Ещё повторение
        throw std::runtime_error("Error occurred");
    }
    
    // Основная обработка...
    
    fclose(file); // Не забыть закрыть!
}

// Оберни ресурс в класс и забудь о нём
{
    ResourceWrapper resource("resource_name");
    // работа с ресурсом
} // Ресурс автоматически освобождён

std::mutex mtx;
 
void unsafeFunction() {
    mtx.lock();
    // Если здесь произойдёт исключение, мьютекс останется заблокированным!
    doSomethingRisky();
    mtx.unlock(); // Эта строка может никогда не выполниться
}
 
// RAII вариант с std::lock_guard
void safeFunction() {
    std::lock_guard<std::mutex> lock(mtx); // Автоматически захватывает мьютекс
    doSomethingRisky(); // Даже если здесь вылетит исключение, мьютекс будет освобождён
} // lock автоматически освобождает мьютекс

std::vector<std::unique_ptr<Resource>> resources;
// Заполняем вектор ресурсами
 
// Функциональная обработка с гарантированной очисткой
std::for_each(resources.begin(), resources.end(), [](const auto& res) {
    res->process();
});
// Все ресурсы будут автоматически освобождены, когда vector будет уничтожен

// Встраиваемая система без исключений
class LimitedBuffer {
private:
    uint8_t* buffer;
    size_t size;
public:
    LimitedBuffer(size_t bufSize) noexcept {
        buffer = static_cast<uint8_t*>(malloc(bufSize));
        size = buffer ? bufSize : 0;
    }
    
    ~LimitedBuffer() noexcept {
        free(buffer);
    }
    
    bool isValid() const noexcept { return buffer != nullptr; }
    
    // Специальная логика для систем с отключенными исключениями
};

class PerfectRAII {
private:
    Resource1* res1;
    Resource2* res2;
public:
    PerfectRAII() : res1(nullptr), res2(nullptr) {
        res1 = new Resource1(); // Может выбросить исключение
        try {
            res2 = new Resource2(); // Тоже может выбросить исключение
        } catch (...) {
            delete res1; // Очистка уже выделенных ресурсов
            throw;      // Передача исключения выше
        }
    }
    
    ~PerfectRAII() {
        delete res2;
        delete res1;
    }
};

class BetterRAII {
private:
    std::unique_ptr<Resource1> res1;
    std::unique_ptr<Resource2> res2;
public:
    BetterRAII() : 
        res1(std::make_unique<Resource1>()),
        res2(std::make_unique<Resource2>()) {
        // Если произойдёт исключение, все уже выделенные ресурсы
        // будут автоматически освобождены
    }
    // Деструктор генерируется автоматически и делает всё правильно!
};

template <typename T>
class CResourcePtr {
private:
    T* ptr;
    void (*deleter)(T*);
public:
    CResourcePtr(T* p, void (*d)(T*)) : ptr(p), deleter(d) {}
    ~CResourcePtr() { if (ptr) deleter(ptr); }
    
    T* get() const { return ptr; }
    
    // Запрет копирования для простоты
    CResourcePtr(const CResourcePtr&) = delete;
    CResourcePtr& operator=(const CResourcePtr&) = delete;
};
 
// Использование
CResourcePtr<FILE> file(fopen("data.txt", "r"), [](FILE* f) { fclose(f); });

class DbTransaction {
private:
    DbConnection& conn;
    bool committed;
public:
    DbTransaction(DbConnection& c) : conn(c), committed(false) {
        conn.execute("BEGIN TRANSACTION");
    }
    
    void commit() {
        conn.execute("COMMIT");
        committed = true;
    }
    
    ~DbTransaction() {
        if (!committed) {
            try {
                conn.execute("ROLLBACK");
            } catch (...) {
                // Логирование, но поглащение исключения,
                // т.к. деструкторы не должны выбрасывать исключения
            }
        }
    }
};

// Вместо этого:
void badFunction() {
Widget* widget = new Widget();
widget->doSomething();
// Упс, забыли delete widget; — утечка!
}
 
// Делайте так:
void goodFunction() {
auto widget = std::make_unique<Widget>();
widget->doSomething();
// Деструктор std::unique_ptr автоматически вызовет delete
}

void complexFunction() {
auto resourceA = std::make_unique<ResourceType>();
// Даже если здесь будет выброшено исключение, память не утечёт
functionThatMightThrow();
auto resourceB = std::make_unique<ResourceType>();
// Работаем с ресурсами...
}

void cleanupOnExit() {
// Создаём анонимный объект, который выполнит cleanup в конце области видимости
auto _ = [cleanup = std::make_unique<SomeCleanupResource>()](){ 
    // Дополнительный код очистки выполнится здесь 
    std::cout << "Cleaning up...\n";
}; 
 
// Основной код функции
if (condition) return; // Даже при раннем возврате cleanup сработает!
}

class ConfigFile {
private:
std::fstream file;
bool modified;
std::string filename;
 
public:
ConfigFile(const std::string& path) : filename(path), modified(false) {
    file.open(path, std::ios::in | std::ios::out);
    if (!file) {
        throw std::runtime_error("Failed to open config file: " + path);
    }
    // Парсинг файла...
}
 
// Сеттеры для изменения конфигурации...
void setValue(const std::string& key, const std::string& value) {
    // Обновляем конфигурацию
    modified = true;
}
 
~ConfigFile() {
    if (modified) {
        // Сохраняем изменения перед закрытием
        file.seekp(0);
        // Записываем обновлённую конфигурацию
        // ...
    }
    file.close();
}
};

class ThreadSafeCounter {
private:
int counter;
std::mutex mtx;
 
public:
ThreadSafeCounter() : counter(0) {}
 
void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    // Мьютекс автоматически освободится даже при исключении
    counter++;
    
    // Представьте сложный код, который может выбросить исключение...
    if (counter == MAX_VALUE) throw std::overflow_error("Counter overflow");
}
 
int getValue() const {
    std::lock_guard<std::mutex> lock(mtx);
    return counter;
}
};

class HttpConnection {
private:
int socketFd;
bool connected;
 
public:
HttpConnection(const std::string& host, int port) {
    socketFd = socket(AF_INET, SOCK_STREAM, 0);
    if (socketFd < 0) {
        throw std::runtime_error("Failed to create socket");
    }
    
    // Настройка и подключение сокета...
    connected = true;
}
 
// Методы для отправки/получения данных...
 
~HttpConnection() {
    if (connected) {
        // Корректно закрываем соединение
        close(socketFd);
    }
}
};

class IncompleteRAII {
private:
Resource* res;
bool initialized;
 
public:
IncompleteRAII() : res(nullptr), initialized(false) {
    res = new Resource();
    
    // Ошибка: не инициализировал resource полностью
    // но не выбросил исключение и не установил флаг
    if (!res->init()) {
        // Упс, забыли обработать ошибку!
    }
    
    initialized = true; // Этот флаг выставится даже при неудачной инициализации!
}
 
void use() {
    if (initialized) {
        res->doSomething(); // Потенциально обращение к неинициализированному ресурсу
    }
}
 
~IncompleteRAII() {
    delete res;
}
};

class ProperRAII {
private:
std::unique_ptr<Resource> res;
 
public:
ProperRAII() {
    auto tempRes = std::make_unique<Resource>();
    if (!tempRes->init()) {
        throw std::runtime_error("Failed to initialize resource");
    }
    res = std::move(tempRes);
}
 
void use() {
    // Ресурс гарантированно инициализирован
    res->doSomething();
}
 
// Деструктор автоматически сгенерирован и корректен
};

class MixedManagementRAII {
private:
Resource* resA;
std::unique_ptr<Resource> resB;
 
public:
MixedManagementRAII() : resA(new Resource()) {
    resB = std::make_unique<Resource>();
}
 
~MixedManagementRAII() {
    delete resA; // Почему не std::unique_ptr и для resA?
}
};

class FlaggedRAII {
private:
FILE* file;
bool valid;
 
public:
FlaggedRAII(const char* filename) : valid(false) {
    file = fopen(filename, "r");
    valid = (file != nullptr);
    // Отсутствие исключения при ошибке — это первая проблема
}
 
~FlaggedRAII() {
    if (valid) {
        fclose(file);
    }
}
 
bool isValid() const { return valid; }
};

class BetterRAII {
private:
FILE* file;
 
public:
BetterRAII(const char* filename) {
    file = fopen(filename, "r");
    if (!file) {
        throw std::runtime_error(std::string("Failed to open file: ") + filename);
    }
}
 
~BetterRAII() {
    fclose(file);
}
};

class DangerousRAII {
private:
int* data;
 
public:
DangerousRAII() : data(new int[100]) {}
~DangerousRAII() { delete[] data; }
 
// Опасно: компилятор сгенерирует копирующий конструктор 
// и оператор присваивания, которые будут некорректно копировать 
// указатель data, приводя к двойному удалению!
};

class SafeRAII {
private:
std::unique_ptr<int[]> data;
 
public:
SafeRAII() : data(std::make_unique<int[]>(100)) {}
// Правило пяти/нуля: используем умный указатель, 
// поэтому можем положиться на сгенерированные функции
};

class ControlledRAII {
private:
int* data;
 
public:
ControlledRAII() : data(new int[100]) {}
~ControlledRAII() { delete[] data; }
 
// Правило пяти: если определен деструктор, 
// определите и остальные специальные функции
ControlledRAII(const ControlledRAII& other) : data(new int[100]) {
    std::copy(other.data, other.data + 100, data);
}
 
ControlledRAII& operator=(const ControlledRAII& other) {
    if (this != &other) {
        std::copy(other.data, other.data + 100, data);
    }
    return *this;
}
 
ControlledRAII(ControlledRAII&& other) noexcept : data(other.data) {
    other.data = nullptr;
}
 
ControlledRAII& operator=(ControlledRAII&& other) noexcept {
    if (this != &other) {
        delete[] data;
        data = other.data;
        other.data = nullptr;
    }
    return *this;
}
};

class ExceptionInDestructorRAII {
private:
Connection conn;
 
public:
ExceptionInDestructorRAII(const std::string& url) : conn(url) {}
 
~ExceptionInDestructorRAII() {
    // Опасно! Деструкторы не должны выбрасывать исключения
    conn.disconnect(); // Может выбросить исключение
}
};

class SafeDestructorRAII {
private:
Connection conn;
 
public:
SafeDestructorRAII(const std::string& url) : conn(url) {}
 
~SafeDestructorRAII() noexcept {
    try {
        conn.disconnect();
    } catch (const std::exception& e) {
        // Логируем ошибку, но не пропускаем исключение наружу
        std::cerr << "Error during disconnect: " << e.what() << std::endl;
    }
}
};

class BaseResource {
private:
    int* data;
public:
    BaseResource() : data(new int[10]) {}
    virtual ~BaseResource() { delete[] data; }
};
 
class DerivedResource : public BaseResource {
private:
    double* moreData;
public:
    DerivedResource() : BaseResource(), moreData(new double[20]) {}
    ~DerivedResource() { delete[] moreData; }
};

class BetterDerivedResource {
private:
    BaseResource baseRes;  // Композиция вместо наследования
    std::unique_ptr<double[]> moreData;
public:
    BetterDerivedResource() : moreData(std::make_unique<double[]>(20)) {}
    // Деструктор сгенерируется автоматически и корректно
};

class Base {
protected:
    virtual void cleanUp() { /* базовая реализация */ }
public:
    virtual ~Base() { cleanUp(); }  // Вызовет Base::cleanUp, даже для Derived объектов!
};
 
class Derived : public Base {
protected:
    void cleanUp() override { /* производная реализация */ }
public:
    ~Derived() override {}
};

void stackRAII() {
    FileHandler file("data.txt");  // На стеке — деструктор вызовется автоматически
    throw std::runtime_error("Oops");  // file всё равно будет закрыт
}
 
void heapRAII() {
    FileHandler* file = new FileHandler("data.txt");  // В куче
    throw std::runtime_error("Oops");  // Утечка! delete никогда не вызовется
    delete file;  // Эта строка недостижима
}

void properHeapRAII() {
    std::unique_ptr<FileHandler> file(new FileHandler("data.txt"));
    // или лучше
    auto file = std::make_unique<FileHandler>("data.txt");
    throw std::runtime_error("Oops");  // Всё в порядке, unique_ptr освободит FileHandler
}

void processFile(FileHandler file) {  // Копирование или перемещение
    // Работа с file
}  // Деструктор для копии вызовется здесь
 
void someFunction() {
    processFile(FileHandler("data.txt"));  // Временный объект
    // Деструктор для временного объекта уже вызвался!
}

void processFileRef(const FileHandler& file) {
    // Работа с file по ссылке
}  // Деструктор не вызывается здесь
 
void betterFunction() {
    FileHandler file("data.txt");
    processFileRef(file);
}  // Деструктор вызовется здесь

NonCopyable createNonCopyable() {
    return NonCopyable();  // Раньше требовался конструктор перемещения,
                          // теперь объект создается сразу в месте назначения
}
 
NonCopyable nc = createNonCopyable();  // Никаких копирований или перемещений!

// Функция, которая создаёт разделяемый ресурс
std::shared_ptr<NetworkConnection> createSharedConnection() {
    return std::shared_ptr<NetworkConnection>(
        new NetworkConnection("server.example.com"),
        [](NetworkConnection* conn) {
            try {
                conn->disconnect();
            } catch (...) {
                // обработка ошибок
            }
            delete conn;
        }
    );
}

void modernFunction() {
// Создание с C++14
auto resource = std::make_unique<HeavyResource>();
 
// Прямое использование, как обычного указателя
resource->doSomething();
 
// Возврат владения из функции
return std::move(resource);
// Если функция завершится досрочно исключением — ресурс будет освобождён
}

// Управление файловым дескриптором
auto file = std::unique_ptr<FILE, decltype([](FILE* f) { fclose(f); })>(
fopen("data.txt", "r"),
[](FILE* f) { if (f) fclose(f); }
);
 
// Или короче с C++17
auto closeFile = [](FILE* f) { if (f) fclose(f); };
auto file = std::unique_ptr<FILE, decltype(closeFile)>(fopen("data.txt", "r"), closeFile);

void sharedOwnership() {
auto sharedConfig = std::make_shared<Configuration>("config.ini");
 
// Теперь можно безопасно передавать указатель нескольким владельцам
startWorker(sharedConfig);
setupUI(sharedConfig);
 
// Конфигурация будет жить, пока жив хотя бы один из них
}

class Node {
private:
std::shared_ptr<Node> next;      // Сильная ссылка на следующий
std::weak_ptr<Node> previous;    // Слабая ссылка на предыдущий
 
public:
void connect(std::shared_ptr<Node> other) {
    next = other;
    other->previous = weak_from_this(); // C++17 magic!
}
};

void containerSafety() {
// Вложенные контейнеры с динамически выделяемыми объектами
std::map<std::string, std::vector<std::unique_ptr<ComplexObject>>> dataStore;
 
// Заполняем структуру
dataStore["group1"].push_back(std::make_unique<ComplexObject>());
dataStore["group1"].push_back(std::make_unique<ComplexObject>());
dataStore["group2"].push_back(std::make_unique<ComplexObject>());
 
// При выходе из функции вся эта сложная структура 
// будет корректно разрушена, включая все уровни вложенности!
}

std::future<Result> asyncOperation(std::shared_ptr<Resource> resource) {
return std::async(std::launch::async, [res = std::move(resource)]() {
    // Ресурс доступен в асинхронной задаче
    res->process();
    
    // Когда все задачи, использующие ресурс, завершатся,
    // счётчик ссылок упадёт до 0, и ресурс будет освобождён
    return Result{};
});
}

Task<Result> coroutineFunction() {
// Ресурс живёт в стековом фрейме корутины
auto resource = std::make_unique<Resource>();
 
// Приостановка корутины — ресурс сохраняется!
co_await someAsyncOperation();
 
// После возобновления ресурс всё ещё доступен
resource->continue_processing();
 
co_return Result{};
// Здесь ресурс будет освобождён, когда корутина завершится
}

Task<void> cancelableOperation(CancellationToken token) {
// Класс, отслеживающий отмену и освобождающий ресурсы
CancellationGuard guard(token);
 
auto resource = std::make_unique<ExpensiveResource>();
co_await setup_resource(resource.get(), token);
 
if (token.is_cancelled()) {
    // Даже при отмене все ресурсы освободятся правильно
    co_return;
}
 
co_await use_resource(resource.get(), token);
}

class OptimizedBuffer {
private:
std::unique_ptr<char[]> data;
size_t size;
 
public:
OptimizedBuffer(size_t s) : data(std::make_unique<char[]>(s)), size(s) {}
 
// Конструктор перемещения — очень эффективен, просто переносит владение
OptimizedBuffer(OptimizedBuffer&& other) noexcept 
    : data(std::move(other.data)), size(other.size) {
    other.size = 0;
}
 
// Оператор перемещения
OptimizedBuffer& operator=(OptimizedBuffer&& other) noexcept {
    if (this != &other) {
        data = std::move(other.data);
        size = other.size;
        other.size = 0;
    }
    return *this;
}
 
// Запрет копирования для недопущения неэффективных операций
OptimizedBuffer(const OptimizedBuffer&) = delete;
OptimizedBuffer& operator=(const OptimizedBuffer&) = delete;
};

template <typename... Args>
void configureResource(Args&&... args) {
// Ресурс создаётся прямо здесь, с идеальной передачей всех аргументов
auto resource = std::make_unique<ConfigurableResource>(
    std::forward<Args>(args)...
);
 
// Использование ресурса...
}

class LimitedPoolResource {
private:
    void* memory;
    static MemoryPool& pool;
 
public:
    LimitedPoolResource(size_t bytes) {
        memory = pool.allocate(bytes);
        if (!memory && bytes > 0) {
            // Вместо исключения — использование стратегии отказоустойчивости
            logCriticalError("Memory allocation failed");
            // Возможно аварийное завершение или другая стратегия восстановления
        }
    }
 
    ~LimitedPoolResource() {
        if (memory) pool.release(memory);
    }
 
    // Запрет копирования, разрешение перемещения
    LimitedPoolResource(const LimitedPoolResource&) = delete;
    LimitedPoolResource& operator=(const LimitedPoolResource&) = delete;
    LimitedPoolResource(LimitedPoolResource&& other) noexcept : memory(other.memory) {
        other.memory = nullptr;
    }
    LimitedPoolResource& operator=(LimitedPoolResource&& other) noexcept {
        if (this != &other) {
            if (memory) pool.release(memory);
            memory = other.memory;
            other.memory = nullptr;
        }
        return *this;
    }
};

class NoExceptRAII {
private:
    resource_t* res;
    bool valid;
 
public:
    NoExceptRAII() noexcept : res(acquireResource()), valid(res != nullptr) {}
    
    ~NoExceptRAII() noexcept {
        if (valid) releaseResource(res);
    }
    
    bool isValid() const noexcept { return valid; }
    
    // Остальной интерфейс...
};
 
void criticalFunction() noexcept {
    NoExceptRAII resource;
    if (!resource.isValid()) {
        // Обработка ошибки без исключений
        return;
    }
    
    // Использование ресурса...
}

template <typename F>
class ScopeGuard {
private:
    F exitFunction;
    bool dismissed;
 
public:
    explicit ScopeGuard(F&& func) : 
        exitFunction(std::forward<F>(func)), 
        dismissed(false) {}
    
    ~ScopeGuard() {
        if (!dismissed) exitFunction();
    }
    
    void dismiss() { dismissed = true; }
    
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
};
 
// Удобный вспомогательный макрос для создания уникального имени
#define CONCAT_IMPL(x, y) x##y
#define CONCAT(x, y) CONCAT_IMPL(x, y)
#define SCOPE_EXIT(func) \
    auto CONCAT(scopeGuard, __LINE__) = ScopeGuard([&]() { func; })

void complexOperation() {
    startLogBatch();
    SCOPE_EXIT(endLogBatch()); // Гарантированно вызовется при выходе
    
    doFirstThing();
    
    if (error_condition) {
        return; // endLogBatch() все равно будет вызван
    }
    
    doSecondThing();
    // endLogBatch() вызовется при нормальном завершении тоже
}

template <typename... Resources>
class Transaction {
private:
    std::tuple<Resources...> resources;
    bool committed;
 
    template <size_t... Indices>
    void rollback(std::index_sequence<Indices...>) {
        // Вызываем rollback для каждого ресурса
        (std::get<Indices>(resources).rollback(), ...);
    }
 
public:
    explicit Transaction(Resources&&... res) :
        resources(std::forward<Resources>(res)...),
        committed(false) {}
    
    void commit() { committed = true; }
    
    ~Transaction() {
        if (!committed) {
            rollback(std::index_sequence_for<Resources...>{});
        }
    }
};

template <typename T>
concept HasReleaseMethod = requires(T t) {
    { t.release() } -> std::same_as<void>;
};
 
template <HasReleaseMethod Resource>
class ResourceGuard {
private:
    Resource resource;
    bool released;
 
public:
    explicit ResourceGuard(Resource&& res) : 
        resource(std::move(res)), 
        released(false) {}
    
    ~ResourceGuard() {
        if (!released) resource.release();
    }
    
    // Остальные методы...
};

asynchronous_generator<int> generateNumbers() {
    // Этот ресурс будет жить до конца выполнения корутины, 
    // даже через приостановки
    auto resource = std::make_unique<HeavyResource>();
    
    for (int i = 0; i < 10; ++i) {
        // Приостановка корутины — ресурс сохраняется
        co_yield i;
        
        // После возобновления ресурс всё еще доступен
        resource->process(i);
    }
    
    // Ресурс автоматически освободится здесь
}