Что такое RAII (Resource Acquisition Is Initialization) в C++ и зачем это нужно?

Что такое RAII на самом деле?

RAII (Resource Acquisition Is Initialization) — это одна из фундаментальных идиом C++, которая связывает время жизни ресурса (память, файловый дескриптор, мьютекс, сокет) с временем жизни объекта. Суть проста: ресурс захватывается в конструкторе объекта и освобождается в его деструкторе. Это гарантирует, что ресурс будет освобождён даже при возникновении исключений или преждевременном выходе из функции.

Почему ваш код плох?

Ваш класс FileHandler явно нарушает RAII:

• Деструктор не закрывает файл — утечка ресурса.
• Конструктор не сообщает об ошибке должным образом (просто пишет в cerr).
• Нет запрета на копирование — если скопировать объект, оба будут пытаться закрыть один файл, что приведёт к двойному освобождению.

Правильная реализация RAII для файла

#include <cstdio>
#include <stdexcept>
#include <string>

class FileHandler {
public:
    // Захват ресурса в конструкторе
    explicit FileHandler(const std::string& filename) 
        : file_(fopen(filename.c_str(), "r")) 
    {
        if (!file_) {
            throw std::runtime_error("Не удалось открыть файл: " + filename);
        }
    }
    
    // Чтение данных
    std::string readLine() {
        char buffer[256];
        if (fgets(buffer, sizeof(buffer), file_)) {
            return std::string(buffer);
        }
        return "";
    }
    
    // Деструктор освобождает ресурс
    ~FileHandler() {
        if (file_) {
            fclose(file_);
        }
    }
    
    // Запрещаем копирование (или реализуем перемещение)
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
    // Разрешаем перемещение (опционально)
    FileHandler(FileHandler&& other) noexcept 
        : file_(other.file_) 
    {
        other.file_ = nullptr;
    }
    
    FileHandler& operator=(FileHandler&& other) noexcept {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }
    
private:
    FILE* file_;
};

// Использование
void processFile() {
    FileHandler fh("data.txt");  // Ресурс захвачен
    auto line = fh.readLine();
    // При выходе из функции деструктор автоматически закроет файл
    // Даже если будет исключение — деструктор вызовется!
}

Классические примеры RAII в стандартной библиотеке

• std::unique_ptr — умный указатель, который автоматически удаляет объект при своём уничтожении.
• std::lock_guard — захватывает мьютекс в конструкторе и освобождает в деструкторе.
• std::ifstream / std::ofstream — открывают файл в конструкторе и закрывают в деструкторе.
• std::vector — управляет динамической памятью, освобождая её при разрушении.

Почему RAII так важен?

Рассмотрим пример без RAII:

void badExample() {
    FILE* f = fopen("test.txt", "r");
    if (!f) return;
    
    // ... какой-то код, который может бросить исключение ...
    if (someCondition) {
        throw std::runtime_error("Ошибка!");
        // fclose(f) НЕ вызовется! Утечка!
    }
    
    fclose(f);  // Если дошли сюда — хорошо
}

С RAII деструктор вызывается автоматически при раскрутке стека (stack unwinding), даже если было исключение. Это делает код безопасным и исключения-устойчивым.

Золотые правила RAII

1. Конструктор захватывает ресурс (или бросает исключение при неудаче).
2. Деструктор освобождает ресурс (никогда не бросает исключения!).
3. Объект не копируется (или копирование корректно управляет ресурсом).
4. Каждый ресурс обёрнут в свой RAII-класс.

Используя RAII, вы превращаете управление ресурсами в автоматический процесс, который не зависит от человеческой памяти или сложной логики обработки ошибок.

// Псевдокод на Java
Resource r = acquire();
try {
    use(r);
} finally {
    r.release();
}

RAIIWrapper r(acquire());  // захват
use(r);                     // использование
// автоматическое освобождение в деструкторе

#include <mutex>

std::mutex mtx;
int shared_data = 0;

void safe_increment() {
    std::lock_guard<std::mutex> lock(mtx);  // захват мьютекса
    ++shared_data;
    // автоматическое освобождение при выходе из функции
}