Что такое правило нуля?

Правило нуля (Rule of Zero): Идиома современного C++

Правило нуля — это фундаментальный принцип современного C++, сформулированный как:

Если твому классу не нужен явный деструктор, не пиши конструктор копирования, оператор присваивания или конструктор перемещения. Пусть компилятор сгенерирует их!

Это противоположность старому "Правилу трёх" (Rule of Three), которое часто приводило к ошибкам и утечкам памяти.

История: От Правила Трёх к Правилу Нуля

Правило Трёх (до C++11) требовало писать все три методы, если пишешь хотя бы один:

class OldStyle {
private:
    char* data;

public:
    OldStyle(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    
    ~OldStyle() { delete[] data; }  // Деструктор
    
    OldStyle(const OldStyle& other) {  // Copy-ctor
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    
    OldStyle& operator=(const OldStyle& other) {  // Copy-assignment
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
};

Это был кошмар: много кода, много ошибок, много возможностей что-то забыть.

Правило Нуля: Используй готовые контейнеры

Вместо ручного управления памятью, используй умные указатели и контейнеры:

class ModernStyle {
private:
    std::string data;  // Управляет собственной памятью!

public:
    ModernStyle(const std::string& str) : data(str) {}
    
    // Всё остальное генерирует компилятор!
    // ~ModernStyle() — не нужен
    // Copy-ctor — компилятор
    // Copy-assignment — компилятор
    // Move-ctor — компилятор (C++11+)
    // Move-assignment — компилятор (C++11+)
};

Ключевая идея: не владеть памятью явно — дай этот труд контейнерам!

Компилятор генерирует методы автоматически

Если ты не пишешь деструктор, компилятор автоматически генерирует (в C++11+):

class Zero {};
// Компилятор автоматически генерирует все 5 методов!

class RuleOfFive {
    ~RuleOfFive() {}  // Если добавляешь деструктор...
    // ...то нужно добавить все остальные 4 метода
};

Практические примеры

Пример 1: RAII контейнер — без явного управления

class FileManager {
private:
    std::unique_ptr<FILE, decltype(&std::fclose)> file{nullptr, &std::fclose};

public:
    FileManager(const std::string& path) {
        file.reset(std::fopen(path.c_str(), "r"));
        if (!file) throw std::runtime_error("Cannot open file");
    }
    // Всё! Компилятор создаст остальное.
    // Деструктор автоматически закроет файл через unique_ptr
};

FileManager fm("file.txt");  // OK
FileManager fm2 = fm;         // Move (unique_ptr не копируется)

Пример 2: Структура данных со стандартными контейнерами

struct User {
    std::string name;           // Управляет строкой
    std::vector<std::string> tags;  // Управляет вектором
    std::map<std::string, int> metadata;  // Управляет картой
    
    // Не нужно писать НИЧЕГО!
    // Компилятор сам сделает Rule of Zero
};

User u1{"Alice", {"admin", "user"}, {}};
User u2 = u1;  // Perfectly works!
User u3 = std::move(u1);  // Move semantics works!

Пример 3: Когда можно НЕ писать методы

class Database {
private:
    std::unique_ptr<sqlite3, decltype(&sqlite3_close)> db{nullptr, &sqlite3_close};
    std::unordered_map<int, User> users;
    std::vector<Log> logs;

public:
    Database(const std::string& path) {
        sqlite3_open(path.c_str(), &db);
        // Не нужны деструктор, copy, move — всё генерируется!
    }
};

Когда нарушить Правило Нуля (Rule of Five)

В редких случаях нужно писать все 5 методов:

class ComplexResource {
private:
    void* external_resource;

public:
    ~ComplexResource() { cleanup(external_resource); }
    
    // Если просто пишешь деструктор, компилятор
    // не генерирует move-методы — нужно писать вручную!
    
    ComplexResource(ComplexResource&& other) noexcept 
        : external_resource(other.external_resource) {
        other.external_resource = nullptr;
    }
    
    ComplexResource& operator=(ComplexResource&& other) noexcept {
        if (this != &other) {
            cleanup(external_resource);
            external_resource = other.external_resource;
            other.external_resource = nullptr;
        }
        return *this;
    }
    
    // Запретим копирование
    ComplexResource(const ComplexResource&) = delete;
    ComplexResource& operator=(const ComplexResource&) = delete;
};

Чеклист: Rule of Zero vs Rule of Five

Rule of Zero (предпочтительно):

• ✓ Используешь std::unique_ptr, std::shared_ptr
• ✓ Используешь std::string, std::vector, std::map
• ✓ Не пишешь деструктор
• ✓ Компилятор генерирует всё

Rule of Five (редко):

• ✗ Управляешь сырыми указателями
• ✗ Пишешь деструктор
• ✗ Нужно написать все 5 методов
• ✗ Много кода, много ошибок

Лучшие практики

1. Используй контейнеры — std::string, std::vector, std::map
2. Умные указатели — std::unique_ptr, std::shared_ptr вместо new/delete
3. Не пиши деструктор, пока не понимаешь почему
4. =default — если нужен default-ctor, пусть компилятор его генерирует
5. =delete — если не хочешь copy/move, явно удали

Результат: Код становится безопаснее, короче, быстрее и менее подвержен ошибкам. Rule of Zero — это идиома, которую должен знать каждый C++ программист.