Что такое идиома Copy-and-Swap в C++ и когда её использовать?

Question

learn_code45 · 09.05.2026

Что такое идиома Copy-and-Swap в C++ и когда её использовать?

Всем привет! Я начал изучать C++ и пытаюсь разобраться с правильным переопределением оператора присваивания. Я знаю, что нужно следить за самоприсваиванием и освобождать старые ресурсы, но мой код выглядит ужасно и я постоянно допускаю ошибки. Вот пример моего класса для работы с динамическим массивом: ```cpp class MyArray { int* data; size_t size; public: MyArray(size_t s) : size(s), data(new int[s]) {} ~MyArray() { delete[] data; } // Проблемный оператор присваивания MyArray& operator=(const MyArray& other) { if (this != &other) { // проверка на самоприсваивание delete[] data; // освобождаем старые данные size = other.size; data = new int[size]; // выделяем новую память std::copy(other.data, other.data + size, data); } return *this; } // Копирующий конструктор тоже есть MyArray(const MyArray& other) : size(other.size), data(new int[other.size]) { std::copy(other.data, other.data + size, data); } }; ``` Но я слышал про какую-то идиому "copy-and-swap", которая якобы решает все эти проблемы разом. Что это такое? Как она работает и почему считается безопасной? Можно ли её применить в моём примере? Буду благодарен за объяснение с примерами. <<>>

Что такое Copy-and-Swap?

Copy-and-Swap — это идиома C++, которая позволяет реализовать оператор присваивания безопасно и элегантно, используя копирующий конструктор и функцию обмена (swap). Основная идея: мы создаём временную копию объекта, а затем обмениваем её содержимое с текущим объектом. Деструктор временного объекта автоматически очистит старые данные.

Почему это безопаснее?

Ваш текущий код имеет несколько проблем:

Исключения при выделении памяти: если new выбросит исключение, объект останется в повреждённом состоянии (уже удалённые данные).
Дублирование логики: копирование данных повторяется в конструкторе и операторе присваивания.
Проверка на самоприсваивание: хоть и не обязательна, но многие её добавляют "на всякий случай", замедляя код.

Copy-and-Swap решает все эти проблемы одной простой техникой.

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

Сначала нам нужна функция swap (можно сделать другом класса):

class MyArray {
    int* data;
    size_t size;
public:
    // Дружественная функция swap для быстрого обмена
    friend void swap(MyArray& first, MyArray& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }
    
    // Конструктор остаётся без изменений
    MyArray(size_t s) : size(s), data(new int[s]) {}
    
    // Копирующий конструктор (нужен обязательно)
    MyArray(const MyArray& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }
    
    // Деструктор
    ~MyArray() { delete[] data; }
    
    // Оператор присваивания — теперь одна строка!
    MyArray& operator=(MyArray other) {  // Принимаем по значению!
        swap(*this, other);              // Обмениваем содержимое
        return *this;
    }
};

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

Параметр по значению: MyArray other создаётся через копирующий конструктор (или перемещающий, если есть). Если копирование выбрасывает исключение — оно происходит до входа в функцию, и наш объект остаётся нетронутым.
Обмен: swap(*this, other) меняет местами data и size текущего объекта и временной копии. Теперь *this владеет новыми данными, а other — старыми.
Автоматическая очистка: при выходе из функции временный объект other уничтожается, его деструктор освобождает старую память.

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

Исключительная безопасность: если копирование не удалось — оператор присваивания даже не вызывается.
Нет дублирования: логика копирования живёт только в конструкторе.
Самоприсваивание безопасно: проверка не нужна, так как обмен с самим собой — это просто обмен указателей.
Единая точка изменения: хотите добавить поле? Обновите конструктор копирования и swap — оператор присваивания сам подстроится.

Важное замечание

Для классов с ресурсами, которые не копируются (например, файловые дескрипторы), идиома также работает, но нужно реализовать перемещающий конструктор и swap. В современном C++ (C++11 и новее) это стандартный подход для "правила пяти".

<<>> Альтернативный взгляд: можно не использовать copy-and-swap, а реализовать оператор присваивания через идиому "copy-and-move" (C++11). Вместо создания копии по значению, вы принимаете параметр по rvalue-ссылке и используете std::move: ```cpp MyArray& operator=(MyArray&& other) noexcept { if (this != &other) { delete[] data; data = other.data; size = other.size; other.data = nullptr; other.size = 0; } return *this; } ``` Плюс отдельный оператор для копирования: ```cpp MyArray& operator=(const MyArray& other) { if (this != &other) { MyArray temp(other); swap(*this, temp); } return *this; } ``` Это даёт больше контроля, если вам нужно оптимизировать производительность или работать с некопируемыми ресурсами. Однако copy-and-swap остаётся золотым стандартом для 90% случаев из-за своей простоты и надёжности. Выбирайте подход под конкретную задачу, но для обучения рекомендую начать с copy-and-swap — он проще для понимания и реже приводит к ошибкам.

0 ответов