Что такое идиома copy-and-swap в C++?

Что такое copy-and-swap idiom?

Идиома copy-and-swap (копирование и обмен) — это элегантный способ реализации оператора присваивания, который одновременно решает три задачи:

• Безопасность исключений — объект никогда не остаётся в повреждённом состоянии
• Избежание дублирования кода — использует уже написанный конструктор копирования
• Корректная работа с самоприсваиванием — не нужно явной проверки if (this != &other)

Основная идея

Идиома состоит из трёх шагов:

1. Создаём временную копию объекта с помощью конструктора копирования
2. Меняем содержимое текущего объекта с временной копией через функцию swap
3. Временная копия уничтожается (в конце области видимости), освобождая старые ресурсы

Ключевой момент — нам нужна noexcept функция обмена (обычно std::swap или своя реализация), которая просто меняет указатели/значения, не выделяя память и не бросая исключений.

Реализация для вашего класса

Добавляем функцию swap и переписываем оператор присваивания:

class String {
public:
    // ... конструкторы и деструктор остаются без изменений ...
    
    // Функция обмена (должна быть noexcept!)
    friend void swap(String& first, String& second) noexcept {
        using std::swap;
        swap(first.size, second.size);
        swap(first.data, second.data);
    }
    
    // Оператор присваивания через copy-and-swap
    String& operator=(String other) {  // Принимаем по значению!
        swap(*this, other);            // Меняем текущий объект с копией
        return *this;
    }
};

Как это работает

Разберём по шагам:

• String& operator=(String other) — параметр передаётся по значению. Это означает, что для создания other будет вызван конструктор копирования (или перемещения). Если копирование не удалось (исключение), то other просто не создастся, а наш объект останется нетронутым.
• swap(*this, other) — мы меняем содержимое *this и other. Поскольку swap не бросает исключений, это безопасно.
• После выхода из функции other уничтожается, вызывая деструктор для старых данных, которые теперь принадлежат other.

Преимущества

• Безопасность исключений (strong exception guarantee) — если что-то пошло не так, объект остаётся в исходном состоянии
• Самоприсваивание — a = a работает корректно: создаётся копия, меняем с собой же, потом копия уничтожается
• Минимум кода — не нужно писать логику копирования в операторе присваивания
• Автоматически получаем move-семантику — если добавить конструктор перемещения, оператор присваивания будет работать и для rvalue

Полный пример

#include <cstring>
#include <algorithm>

class String {
    char* data;
    size_t size;
    
public:
    String(const char* str = "") 
        : size(strlen(str)), data(new char[size + 1]) {
        strcpy(data, str);
    }
    
    String(const String& other) 
        : size(other.size), data(new char[size + 1]) {
        strcpy(data, other.data);
    }
    
    // Конструктор перемещения (C++11)
    String(String&& other) noexcept 
        : data(nullptr), size(0) {
        swap(*this, other);
    }
    
    ~String() { delete[] data; }
    
    friend void swap(String& first, String& second) noexcept {
        using std::swap;
        swap(first.size, second.size);
        swap(first.data, second.data);
    }
    
    String& operator=(String other) {
        swap(*this, other);
        return *this;
    }
};

Идиома copy-and-swap — это мощный инструмент, который делает код безопаснее, проще и короче. Используйте её везде, где класс управляет ресурсами (память, файлы, мьютексы).

String a("Hello world");
String b("C++ programming");
a = b;  // Создаётся копия b, потом обмен, потом удаление старой памяти a

String& operator=(const String& other) {
    if (this != &other) {
        // Пытаемся переиспользовать память
        if (size != other.size) {
            delete[] data;
            data = new char[other.size + 1];
            size = other.size;
        }
        strcpy(data, other.data);
    }
    return *this;
}