Resource Acquisition is Initialization (RAII) в C++

// Старый подход — каждый return требует освобождения ресурсов
void oldWay(/*...*/) {
    Resource* res = new Resource();
    if (badCondition) {
        delete res; // Не забываем!
        return;
    }
    // ... какая-то логика ...
    if (anotherCondition) {
        delete res; // И тут не забываем!
        return;
    }
    // ... ещё логика ...
    delete res; // И здесь тоже!
}
 
// Подход RAII — деструктор сработает автоматически
void raiiWay(/*...*/) {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    if (badCondition) return;
    // ... какая-то логика ...
    if (anotherCondition) return;
    // ... ещё логика ...
} // res уничтожается автоматически при любом выходе из функции

void рискованная_функция() {
    std::unique_ptr<Resource> ресурс = std::make_unique<Resource>();
    std::vector<int> большой_массив(1000);
    std::lock_guard<std::mutex> блокировка(глобальный_мьютекс);
    
    // Если тут выбросится исключение...
    делаем_что_то_опасное();
    
    // Мы сюда не дойдём, но это не проблема:
    // - lock_guard освободит мьютекс
    // - vector освободит свою память
    // - unique_ptr уничтожет Resource
}

try {
    небезопасные_операции();
} catch (const std::exception& e) {
    std::cerr << "Упс: " << e.what() << std::endl;
}

class FileHandler {
private:
    FILE* file;
public:
    // Приобретение ресурса при инициализации
    FileHandler(const char* filename, const char* mode) {
        file = fopen(filename, mode);
        if (!file) throw std::runtime_error("Не могу открыть файл");
    }
    
    // Освобождение ресурса при уничтожении
    ~FileHandler() {
        if (file) fclose(file);
    }
    
    // Методы для работы с файлом
    void write(const char* data) {
        fputs(data, file);
    }
};

void writeToLogFile(const char* message) {
    FileHandler log("app.log", "a"); // Файл открывается здесь
    log.write(message);
    log.write("\n");
    // Никакого вызова close() — файл закроется автоматически
} // <-- Здесь сработает деструктор, который закроет файл

void oldStyleWriteToLog(const char* message) {
    FILE* file = fopen("app.log", "a");
    if (!file) return; // Упс, забыли сообщить об ошибке!
    
    fputs(message, file);
    fputs("\n", file);
    
    if (someCondition) {
        // Ой, тут тоже надо закрыть
        fclose(file);
        return;
    }
    
    // Ещё где-то может понадобиться выход из функции...
    
    fclose(file); // Легко забыть при редактировании кода
}

class VectorHolder {
private:
double* elements;
size_t count;
public:
VectorHolder(size_t n) : count(n), elements(new double[n]) {}
~VectorHolder() { delete[] elements; }
// ... методы доступа к элементам ...
};

void старинный_метод() {
    int* arr = new int[1000];
    // Куча кода...
    if (какое_то_условие) {
        // Ой, забыли delete[] arr
        return;
    }
    // Ещё куча кода...
    delete[] arr; // Надеемся, что сюда доберёмся
}

void метод_c_плюс_плюс_98() {
    std::vector<int> arr(1000);
    // Куча кода...
    if (какое_то_условие) {
        return; // Вектор подчистит за собой!
    }
    // Ещё куча кода...
} // vector автоматически деаллоцирует память

void современный_метод() {
    auto ресурс = std::make_unique<Resource>();
    ресурс->делай_что_то();
    
    if (нужно_передать_владение) {
        return функция_принимает_уникальный_указатель(std::move(ресурс));
    }
    
    auto разделяемый = std::make_shared<HeavyResource>();
    сложная_асинхронная_операция(разделяемый);
} // Оба ресурса будут корректно освобождены

// C++98: Неуклюжий auto_ptr
std::auto_ptr<Resource> res(new Resource());
функция_использующая_ресурс(res.get());
// Невозможно безопасно передать владение
 
// C++11: Более гибкий unique_ptr
std::unique_ptr<Resource> res = std::make_unique<Resource>();
функция_использующая_ресурс(res.get());
другая_функция(std::move(res)); // Явная передача владения
 
// C++17: Структурное связывание и улучшенные инициализаторы
auto [file, success] = открыть_файл("data.txt");
if (success) {
    // файл автоматически закроется при выходе из области видимости
}
 
// C++20: Использование концептов с RAII
template<typename T>
requires std::destructible<T>
class ScopedResource {
    T resource;
public:
    // ...
};

// Без RAII: код погребён под управлением ресурсами
bool processFIle(const char* path) {
FILE* file = fopen(path, "r");
if (!file) return false;
 
char* buffer = new char[4096];
if (!buffer) {
    fclose(file);
    return false;
}
 
size_t bytesRead = fread(buffer, 1, 4096, file);
if (bytesRead == 0) {
    delete[] buffer;
    fclose(file);
    return false;
}
 
// Обработка данных...
 
delete[] buffer;
fclose(file);
return true;
}
 
// С использованием RAII: чистый и понятный код
bool processFileRaii(const char* path) {
std::ifstream file(path);
if (!file) return false;
 
std::vector<char> buffer(4096);
size_t bytesRead = file.read(buffer.data(), buffer.size()).gcount();
if (bytesRead == 0) return false;
 
// Обработка данных...
 
return true;
}

class FileResource {
private:
    std::FILE* handle;
public:
    FileResource(const char* filename) : handle(std::fopen(filename, "r")) {
        if (handle == nullptr) throw std::runtime_error("Не удалось открыть файл");
    }
    
    ~FileResource() {
        std::fclose(handle); // Всегда выполняется при уничтожении
    }
};

class System {
private:
DatabaseConnection db;
Logger log; // зависит от db для логирования
public:
// ...
};

template <typename Resource, typename Deleter>
class ScopedResource {
private:
Resource res;
Deleter del;
public:
ScopedResource(Resource r, Deleter d) : res(r), del(d) {}
~ScopedResource() { del(res); }
// ...
};

// Плохо: класс делает слишком много
class DatabaseConnection {
private:
    MYSQL* connection;
public:
    DatabaseConnection(const char* host, const char* user, const char* pass) {
        connection = mysql_init(nullptr);
        mysql_real_connect(connection, host, user, pass, nullptr, 0, nullptr, 0);
    }
    
    ~DatabaseConnection() {
        mysql_close(connection);
    }
    
    // Кроме управления соединением, класс занимается бизнес-логикой
    std::vector<User> getAllUsers() {
        // ... запрос к БД, обработка результатов, маппинг на объекты ...
    }
    
    void updateUserProfile(const User& user) {
        // ... генерация SQL-запроса, выполнение ...
    }
};

// Хорошо: каждый класс занимается своим делом
class DbConnection {
private:
    MYSQL* connection;
public:
    DbConnection(const char* host, const char* user, const char* pass) {
        connection = mysql_init(nullptr);
        mysql_real_connect(connection, host, user, pass, nullptr, 0, nullptr, 0);
    }
    
    ~DbConnection() {
        mysql_close(connection);
    }
    
    // Только низкоуровневый доступ к ресурсу
    MYSQL* getHandle() { return connection; }
};
 
// Отдельный класс для работы с данными
class UserRepository {
private:
    DbConnection& db;
public:
    UserRepository(DbConnection& connection) : db(connection) {}
    
    std::vector<User> getAllUsers() {
        // Используем db.getHandle() для доступа к соединению
    }
};

{
std::vector<MyHeavyClass> тяжёлые_объекты;
тяжёлые_объекты.push_back(MyHeavyClass("Первый"));
тяжёлые_объекты.emplace_back("Второй"); // C++11 и выше
 
// Где-то дальше в коде...
if (что_то_пошло_не_так) throw std::runtime_error("Упс!");
} // <- Деструктор vector автоматически:
// 1. Вызовет деструктор для каждого элемента
// 2. Освободит занятую память

template <typename T, typename Allocator = std::allocator<T>>
class vector {
private:
T* elements;           // Указатель на начало выделенной памяти
size_t count;          // Количество элементов
size_t capacity;       // Выделенная ёмкость
Allocator alloc;       // Объект-аллокатор
 
public:
vector() : elements(nullptr), count(0), capacity(0) {}
 
~vector() {
    // Вызываем деструкторы всех элементов
    for (size_t i = 0; i < count; ++i) {
        elements[i].~T();
    }
    // Освобождаем память
    alloc.deallocate(elements, capacity);
}
// ... остальные методы ...
};

// Старый подход (не делайте так!)
Resource* res = new Resource();
// ... работа с ресурсом ...
delete res; // Легко забыть или пропустить при исключении
 
// RAII-подход с unique_ptr
auto res = std::make_unique<Resource>();
// Просто используйте ресурс и не думайте об освобождении

void старт_асинхронной_задачи() {
auto ресурс = std::make_shared<Resource>();
// Теперь несколько объектов могут владеть ресурсом
std::thread t1([ресурс] { использовать_ресурс(ресурс); });
std::thread t2([ресурс] { тоже_использовать_ресурс(ресурс); });
t1.detach();
t2.detach();
// Ресурс будет жить, пока хотя бы один поток его использует
}

void записать_логи(const std::string& сообщение) {
std::ofstream файл_лога("application.log", std::ios::app);
if (!файл_лога) {
    throw std::runtime_error("Не могу открыть лог-файл");
}
файл_лога << временная_метка() << ": " << сообщение << std::endl;
// Файл закроется автоматически при выходе из функции
}

std::mutex данные_мьютекс;
 
void обновить_общие_данные() {
// RAII-обёртка автоматически освободит мьютекс
std::lock_guard<std::mutex> блокировка(данные_мьютекс);
// Теперь у нас эксклюзивный доступ к данным
обновить_данные();
// При любом выходе из функции мьютекс будет разблокирован
}

bool попытка_обновления() {
std::unique_lock<std::mutex> блокировка(данные_мьютекс, std::try_to_lock);
if (!блокировка.owns_lock()) {
    return false; // Не смогли захватить мьютекс
}
обновить_данные();
return true;
}

class DbConnection {
private:
    SQLite3* db;
public:
    DbConnection(const std::string& dbPath) : db(nullptr) {
        if (sqlite3_open(dbPath.c_str(), &db) != SQLITE_OK) {
            throw std::runtime_error("Не могу открыть базу данных");
        }
    }
    
    ~DbConnection() {
        sqlite3_close(db);
    }
    
    // Интерфейс для выполнения запросов
    SQLite3* get() { return db; }
};
 
void обновить_профиль(int userId, const std::string& newName) {
    DbConnection conn("users.db"); // Соединение откроется здесь
    // Запрос и обработка...
    // При любом исходе соединение закроется автоматически
}

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

void перевести_деньги(int с_аккаунта, int на_аккаунт, double сумма) {
    DbConnection db("bank.db");
    Transaction tx(db); // Транзакция начинается
    
    // Любое исключение приведёт к откату транзакции
    снять_со_счёта(db, с_аккаунта, сумма);
    зачислить_на_счёт(db, на_аккаунт, сумма);
    
    tx.commit(); // Явно подтверждаем успешное завершение
}

template<typename F>
class ScopeGuard {
    F cleanup;
    bool active;
public:
    ScopeGuard(F f) : cleanup(std::move(f)), active(true) {}
    
    ~ScopeGuard() {
        if (active) cleanup();
    }
    
    void dismiss() { active = false; }
    
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
};
 
// Удобный хэлпер
template<typename F>
ScopeGuard<F> make_scope_guard(F f) {
    return ScopeGuard<F>(std::move(f));
}

void какая_то_функция() {
    auto* буфер = new char[1024];
    auto guard = make_scope_guard([&]{ delete[] буфер; });
    
    // Теперь можно не беспокоиться о cleanup...
    if (условие_выхода) return; // буфер всё равно будет удалён
    
    // Если мы передаём владение буфером куда-то ещё:
    передать_владение(буфер);
    guard.dismiss(); // Отменяем очистку
}

class критическая_секция {
private:
    std::mutex& mtx;
public:
    критическая_секция(std::mutex& m) : mtx(m) {
        mtx.lock();
    }
    
    ~критическая_секция() {
        mtx.unlock();
    }
    
    template<typename Func>
    auto execute(Func&& f) {
        return std::forward<Func>(f)();
    }
};
 
// Использование
std::mutex г_мьютекс;
 
void защищённая_работа() {
    критическая_секция cs(г_мьютекс);
    cs.execute([]{ // Код выполнится в защищенном контексте
        обновить_общие_данные();
    });
}

class MyResource {
private:
    ResType* resource;
public:
    // Конструктор захватывает ресурс
    MyResource(const std::string& name) {
        resource = acquireResource(name);
        if (!resource) throw std::runtime_error("Не удалось захватить ресурс");
    }
    
    // Деструктор освобождает ресурс
    ~MyResource() {
        if (resource) releaseResource(resource);
    }
    
    // Доступ к ресурсу
    ResType* get() const { return resource; }
};

// Запрещаем копировнание
MyResource(const MyResource&) = delete;
MyResource& operator=(const MyResource&) = delete;

// Конструктор перемещения
MyResource(MyResource&& other) noexcept 
    : resource(other.resource) {
    other.resource = nullptr; // Передаём владение ресурсом
}
 
// Оператор присваивания при перемещении
MyResource& operator=(MyResource&& other) noexcept {
    if (this != &other) {
        if (resource) releaseResource(resource);
        resource = other.resource;
        other.resource = nullptr;
    }
    return *this;
}

ResType* release() {
    ResType* tmp = resource;
    resource = nullptr;
    return tmp;
}

class ResourceWrapper {
private:
resource_handle_t handle;
public:
ResourceWrapper(const char* name) : handle(create_resource(name)) {
    if (!handle) throw std::runtime_error("Не удалось создать ресурс");
}
 
~ResourceWrapper() {
    if (handle) destroy_resource(handle);
}
 
// Запрет копирования
ResourceWrapper(const ResourceWrapper&) = delete;
ResourceWrapper& operator=(const ResourceWrapper&) = delete;
 
// Разрешаем перемещение
ResourceWrapper(ResourceWrapper&& other) noexcept : handle(other.handle) {
    other.handle = nullptr;
}
 
// Доступ к ресурсу для использования в C API
resource_handle_t get() const { return handle; }
 
// Метод использования ресурса (опциональный "сахар")
void use(int param) {
    use_resource(handle, param);
}
};

void делаем_что_то_полезное() {
ResourceWrapper res("important_resource");
res.use(42);
// Явный вызов destroy_resource больше не нужен
}

resource_handle_t release() {
    auto tmp = handle;
    handle = nullptr;
    return tmp;
}

template <typename Handle, typename Traits>
class RAIIWrapper {
private:
Handle handle;
bool owns;
public:
explicit RAIIWrapper(Handle h = Traits::invalid()) : handle(h), owns(h != Traits::invalid()) {}
 
// Явное принятие владения
explicit RAIIWrapper(Handle h, bool take_ownership) : handle(h), owns(take_ownership) {}
 
~RAIIWrapper() {
if (owns && handle != Traits::invalid()) {
    Traits::close(handle);
}
}
 
// Запрет копирования
RAIIWrapper(const RAIIWrapper&) = delete;
RAIIWrapper& operator=(const RAIIWrapper&) = delete;
 
// Поддержка перемещения
RAIIWrapper(RAIIWrapper&& other) noexcept : handle(other.handle), owns(other.owns) {
other.owns = false;
}
 
// Методы доступа
Handle get() const { return handle; }
Handle release() {
owns = false;
return handle;
}
};

struct SQLiteTraits {
using Handle = sqlite3*;
static Handle invalid() { return nullptr; }
static void close(Handle h) { sqlite3_close(h); }
};
 
using SQLiteDB = RAIIWrapper<sqlite3*, SQLiteTraits>;

struct FileHandleTraits {
using Handle = HANDLE;
static Handle invalid() { return INVALID_HANDLE_VALUE; }
static void close(Handle h) { CloseHandle(h); }
};
 
using FileHandle = RAIIWrapper<HANDLE, FileHandleTraits>;

template <typename Func>
void выполнить_с_ресурсом(const std::string& имя, Func&& операция) {
ResourceWrapper ресурс(имя);
операция(ресурс.get());
}

class УязвимыйРАИИ {
    Ресурс* ресурс;
public:
    УязвимыйРАИИ() : ресурс(новый_ресурс()) {}
    ~УязвимыйРАИИ() { удалить_ресурс(ресурс); }
    // Упс! Нет = delete для конструкторов копирования и операторов присваивания
};
 
{
    УязвимыйРАИИ а;
    УязвимыйРАИИ б = а; // Оба объекта теперь указывают на один ресурс
} // Бум! Двойное удаление

struct Узел {
    std::shared_ptr<Узел> следующий;
};
 
void создать_цикл() {
    auto a = std::make_shared<Узел>();
    auto b = std::make_shared<Узел>();
    a->следующий = b;
    b->следующий = a; // Цикл! Ни a, ни b никогда не будут освобождены
}

~МойКласс() noexcept {
    try {
        рискованная_операция();
    } catch (const std::exception& e) {
        // Логируем, но не пробрасываем дальше!
        std::cerr << "Ошибка в деструкторе: " << e.what() << std::endl;
    }
}