Как реализуется оператор копирования по умолчанию?

Оператор копирования по умолчанию в C++

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

Оператор копирования (copy assignment operator) — это специальный оператор operator=, который создаёт копию одного объекта в другой. Он является одним из пяти специальных членов класса (special member functions), которые компилятор может автоматически генерировать.

Автоматическая генерация компилятором

Когда вы не определяете оператор копирования явно, компилятор автоматически генерирует версию по умолчанию (default copy assignment operator). Эта генерируемая версия выполняет поверхностное копирование (shallow copy) всех членов класса:

class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
};

// Компилятор автоматически генерирует:
// Point& operator=(const Point& other) {
//     x = other.x;
//     y = other.y;
//     return *this;
// }

Проблема поверхностного копирования

Поверхностное копирование работает хорошо для простых типов, но становится проблемой с динамически выделенной памятью:

class String {
private:
    char* data;
    int length;
public:
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }
    
    ~String() { delete[] data; }
};

String s1("Hello");
String s2 = s1;  // Копируются только указатели!
// Теперь s1.data и s2.data указывают на одну память
// Удаление s1 удалит память, и s2 получит висячий указатель

Явное определение оператора копирования

Для класса с динамической памятью нужно определить глубокое копирование (deep copy):

class String {
private:
    char* data;
    int length;
public:
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }
    
    // Copy assignment operator
    String& operator=(const String& other) {
        // Проверка самоприсваивания
        if (this == &other) return *this;
        
        // Освобождение старой памяти
        delete[] data;
        
        // Выделение новой памяти и копирование
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        
        return *this;
    }
    
    ~String() { delete[] data; }
};

Правило трёх (The Rule of Three)

Если вы определяете деструктор, конструктор копирования или оператор копирования, вы обычно должны определить все три:

class Resource {
private:
    int* data;
    int size;
public:
    // Конструктор
    Resource(int n) : size(n) {
        data = new int[n];
    }
    
    // Конструктор копирования
    Resource(const Resource& other) : size(other.size) {
        data = new int[size];
        memcpy(data, other.data, size * sizeof(int));
    }
    
    // Оператор копирования
    Resource& operator=(const Resource& other) {
        if (this == &other) return *this;
        delete[] data;
        size = other.size;
        data = new int[size];
        memcpy(data, other.data, size * sizeof(int));
        return *this;
    }
    
    // Деструктор
    ~Resource() { delete[] data; }
};

Правило пяти (The Rule of Five) в C++11

В современном C++ добавились move конструктор и move assignment, поэтому лучше определять все пять:

class Resource {
public:
    // 1. Конструктор копирования
    Resource(const Resource& other);
    
    // 2. Оператор копирования
    Resource& operator=(const Resource& other);
    
    // 3. Move конструктор
    Resource(Resource&& other) noexcept;
    
    // 4. Move assignment
    Resource& operator=(Resource&& other) noexcept;
    
    // 5. Деструктор
    ~Resource();
};

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

• Если вы явно определили конструктор копирования, деструктор или оператор копирования (в C++98)
• Если класс содержит членов с удалённым оператором копирования
• Если есть базовый класс с удалённым оператором копирования

Удаление оператора копирования

В современном C++ можно запретить копирование явно:

class NonCopyable {
public:
    NonCopyable() = default;
    
    // Запретить копирование
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
    
    // Разрешить перемещение
    NonCopyable(NonCopyable&&) noexcept = default;
    NonCopyable& operator=(NonCopyable&&) noexcept = default;
};

Ключевые моменты

• Поверхностное копирование компилятора подходит только для простых типов
• Глубокое копирование необходимо для классов с динамической памятью
• Всегда проверяйте самоприсваивание (this == &other)
• Оператор копирования должен возвращать *this для цепочки присваиваний
• В C++11+ используйте правило пяти, включая move-операции