Что такое семантика перемещения (move semantics) в C++11 и как она работает?

Суть семантики перемещения: избавляемся от лишних копирований

Вы абсолютно правы: в вашем примере при возврате temp из функции происходит ненужное глубокое копирование огромного массива, хотя исходный объект всё равно будет уничтожен. Move semantics (семантика перемещения) решает именно эту проблему — она позволяет "перехватить" ресурсы (например, выделенную память) у временного объекта, который скоро умрёт, вместо того чтобы копировать их.

Как это работает: rvalue-ссылки (&&)

Ключевой механизм — rvalue-ссылки, обозначаемые двумя амперсандами &&. Они могут привязываться только к временным объектам (rvalue). Когда компилятор видит, что возвращается временный объект, он предпочитает вызвать версию конструктора/оператора с &&, а не с const&.

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

Вот как должны выглядеть конструктор перемещения и оператор присваивания перемещением:

class MyArray {
public:
    int* data;
    size_t size;

    // ... остальной код ...

    // Конструктор перемещения (move constructor)
    MyArray(MyArray&& other) noexcept 
        : data(other.data), size(other.size)  // Просто крадём указатель
    {
        other.data = nullptr;  // Обнуляем источник, чтобы он не удалил данные
        other.size = 0;
        std::cout << "Move constructor called\n";
    }

    // Оператор присваивания перемещением (move assignment)
    MyArray& operator=(MyArray&& other) noexcept {
        if (this != &other) {
            delete[] data;  // Освобождаем свои старые ресурсы
            
            // Крадём ресурсы у other
            data = other.data;
            size = other.size;
            
            // Обнуляем источник
            other.data = nullptr;
            other.size = 0;
            
            std::cout << "Move assignment called\n";
        }
        return *this;
    }

    // Деструктор должен быть безопасным для "пустого" объекта
    ~MyArray() {
        delete[] data;  // delete nullptr — безопасно
        std::cout << "Destructor called\n";
    }
};

Что изменилось?

• Конструктор перемещения (MyArray(MyArray&& other)) не выделяет новую память — он просто копирует указатель data и размер, а затем обнуляет other.data. Теперь два объекта не разделяют один буфер, и деструктор other безопасно удалит nullptr.
• Оператор присваивания перемещением сначала освобождает свои старые данные, затем крадёт данные у other и обнуляет источник.
• Оба помечены noexcept — это важно для эффективной работы стандартных контейнеров (например, std::vector будет использовать перемещение вместо копирования при реаллокации).

Как это применяется на практике

Теперь при возврате из функции:

MyArray createArray() {
    MyArray temp(1000000);
    return temp;  // Компилятор: "temp — это lvalue, но я могу применить move"
}

Компилятор видит, что temp — локальная переменная, которая будет уничтожена. Он автоматически преобразует её в rvalue (как если бы вы написали std::move(temp)). В результате вызывается конструктор перемещения, а не копирования. Вместо выделения нового массива на 1 млн элементов и копирования всех данных — просто перебрасывается указатель. Это O(1) вместо O(n).

В строке MyArray arr2 = arr; (где arr — это lvalue, именованный объект) по-прежнему вызовется конструктор копирования, потому что arr не является временным. Если вы хотите принудительно переместить именованный объект, используйте std::move(arr).

Правило пяти (Rule of Five)

Если вы определяете любой из следующих методов, скорее всего, нужно определить все пять:

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

В вашем случае это необходимо, так как класс управляет динамической памятью.

MyArray createArray() {
    return MyArray(1000000);  // C++17: гарантированный copy elision
}

int main() {
    MyArray arr = createArray(); // Никаких перемещений/копирований!
}