Правило трех / пяти / нуля

Часть раздела Объектно-ориентированное программирование путешествия по C++ на Coddy. Урок 25 из 104.

Если ваш класс управляет такими ресурсами, как динамическая память, вы уже узнали, что вам нужны пользовательские деструктор, конструктор копирования и конструктор перемещения. Но есть принцип, который помогает решить, какие специальные функции-члены реализовать: правило трёх, пяти и нуля.

Правило трёх гласит: если вы определяете любой из этих трёх элементов, следует определить все три:

Деструктор
Конструктор копирования
Оператор присваивания копированием

Правило пяти расширяет это для современного C++, добавляя операции перемещения:

Деструктор
Конструктор копирования
Оператор присваивания копированием
Конструктор перемещения
Оператор присваивания перемещением

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    
    ~Buffer() { delete[] data; }                          // 1. Деструктор
    Buffer(const Buffer& other);                          // 2. Конструктор копирования
    Buffer& operator=(const Buffer& other);               // 3. Оператор копирующего присваивания
    Buffer(Buffer&& other) noexcept;                      // 4. Конструктор перемещения
    Buffer& operator=(Buffer&& other) noexcept;           // 5. Оператор перемещающего присваивания
};

Операторы присваивания следуют одному шаблону: проверяют, не выполняется ли самоприсваивание, освобождают старый ресурс, принимают новый и возвращают *this:

Buffer& Buffer::operator=(const Buffer& other) {   // копирующее присваивание
    if (this != &other) {
        delete[] data;
        size = other.size;
        data = new int[size];
        std::copy(other.data, other.data + size, data);
    }
    return *this;
}

Buffer& Buffer::operator=(Buffer&& other) noexcept {   // перемещающее присваивание
    if (this != &other) {
        delete[] data;
        data = other.data;
        size = other.size;
        other.data = nullptr;
        other.size = 0;
    }
    return *this;
}

Правило нуля — это самый простой подход: если ваш класс напрямую не управляет ресурсами, не определяйте ни одну из этих функций. Позвольте компилятору сгенерировать их или используйте умные указатели и стандартные контейнеры, которые сами управляют ресурсами.

class Player {
    std::string name;              // std::string самостоятельно управляет своей памятью
    std::vector<int> scores;       // std::vector самостоятельно управляет своими ресурсами
public:
    Player(std::string n) : name(n) {}
    // Деструктор, функции копирования и перемещения не нужны!
};

Соблюдение этих правил предотвращает ошибки, такие как двойное удаление, утечки памяти и висячие указатели, которые возникают, когда одни операции определены, а другие отсутствуют.

Задание

Легко

Давайте создадим класс TextBuffer, который следует Правилу пяти: реализуем все пять специальных функций-членов для правильного управления динамически выделяемыми символьными данными. Так мы покажем, как операции копирования и перемещения работают вместе, обеспечивая надёжное управление ресурсами в классе.

Для организации кода создайте два файла:

TextBuffer.h: определите класс TextBuffer, который хранит текст в динамически выделенном символьном массиве. Класс должен содержать:
- Приватные члены: указатель char* с именем data для текстовых данных и переменную size_t length для длины строки (без учёта завершающего нулевого символа)
- Параметризованный конструктор, принимающий C-строку (const char*), выделяющий память, копирующий содержимое и выводящий "TextBuffer created: <text>"
- Деструктор, который освобождает память (если указатель не равен null) и выводит "TextBuffer destroyed"
- Конструктор копирования, который выполняет глубокое копирование и выводит "TextBuffer copied"
- Оператор присваивания копированием, который обрабатывает самоприсваивание, освобождает ранее занятые данные, выполняет глубокое копирование и выводит "TextBuffer copy-assigned". Возвращайте *this
- Конструктор перемещения (помеченный noexcept), который передаёт владение и выводит "TextBuffer moved". Оставьте исходный объект в допустимом пустом состоянии
- Оператор присваивания перемещением (помеченный noexcept), который обрабатывает самоприсваивание, освобождает ранее занятые данные, передаёт владение и выводит "TextBuffer move-assigned". Возвращайте *this
- Метод getText(), который возвращает сохранённый текст (возвращайте пустую строку "", если data равен null)
- Метод getLength(), который возвращает длину
main.cpp: продемонстрируйте работу всех пяти специальных функций-членов. Считайте текстовую строку из ввода, затем:
- Создайте TextBuffer с именем original, содержащий введённый текст
- Создайте copied с помощью конструктора копирования из original
- Создайте another с текстом "Temporary"
- Выполните присваивание копированием: another = original
- Создайте moved с помощью конструктора перемещения из original, используя std::move()
- Создайте target с текстом "Target"
- Выполните присваивание перемещением: target = std::move(copied)
- Выведите "--- Final State ---"
- Выведите "original: <text> (length: <len>)" для каждого буфера: original, copied, moved, another, target

После перемещений исходные объекты (original и copied) должны содержать пустой текст и иметь длину 0, а объекты-получатели — хранить переданные данные. Это демонстрирует Правило пяти в действии: все пять функций работают вместе, обеспечивая безопасное управление ресурсами.

Подключите <cstring> для строковых функций, таких как strlen и strcpy, и <utility> для std::move().

Попробуйте сами

#include <iostream>
#include <string>
#include <utility>
#include "TextBuffer.h"

using namespace std;

int main() {
    string input;
    getline(cin, input);

    // TODO: Создайте TextBuffer с именем 'original', содержащий введённый текст

    // TODO: Создайте 'copied' с помощью конструктора копирования из 'original'

    // TODO: Создайте 'another' с текстом "Temporary"

    // TODO: Используйте копирующее присваивание: another = original

    // TODO: Создайте 'moved' с помощью конструктора перемещения из 'original', используя std::move()

    // TODO: Создайте 'target' с текстом "Target"

    // TODO: Используйте перемещающее присваивание: target = std::move(copied)

    // TODO: Выведите "--- Final State ---"

    // TODO: Выведите состояние каждого буфера в следующем формате:
    // "original: <text> (length: <len>)"
    // Выведите данные для: original, copied, moved, another, target

    return 0;
}