Что такое std::move() и когда его нужно использовать в C++?

Что такое std::move() на самом деле?

Прежде всего, важно понять: std::move() не перемещает объект сам по себе. Это просто приведение типа (cast) к rvalue-ссылке. Он говорит компилятору: "Эй, этот объект можно рассматривать как временный, разреши для него семантику перемещения".

Когда вы пишете std::move(obj), вы буквально говорите: "Я разрешаю "украсть" ресурсы у этого объекта". После этого, если вызывается конструктор перемещения или оператор присваивания перемещением, они могут забрать внутренние данные (например, указатели на динамическую память) у исходного объекта, оставив его в "пустом", но валидном состоянии.

Как это работает под капотом?

Рассмотрим пример с std::string. У строки есть конструктор копирования (глубокое копирование) и конструктор перемещения (перехват указателя на внутренний буфер).

#include <iostream>
#include <string>

class MyString {
private:
    char* data;
    size_t size;
public:
    // Конструктор копирования (глубокое копирование)
    MyString(const MyString& other) : size(other.size) {
        data = new char[size];
        std::copy(other.data, other.data + size, data);
        std::cout << "Копирование " << size << " байт\n";
    }
    
    // Конструктор перемещения (перехват ресурсов)
    MyString(MyString&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;  // Оставляем источник в пустом состоянии
        other.size = 0;
        std::cout << "Перемещение (украдено " << size << " байт)\n";
    }
    
    ~MyString() { delete[] data; }
};

int main() {
    MyString source("Привет, мир! Это длинная строка...");
    
    // Явное копирование
    MyString copy1(source);           // Копирование
    
    // Перемещение через std::move
    MyString moved(std::move(source)); // Перемещение
    
    // source теперь пустая (data == nullptr), но валидна
    // Её можно уничтожить или присвоить новое значение
}

Когда использовать std::move()?

• Передача владения: Когда объект больше не нужен в текущем контексте, и вы хотите избежать дорогого копирования.
• Возврат из функции: Компилятор часто сам применяет move (RVO/NRVO), но в сложных случаях может помочь явный move.
• Вставка в контейнеры: vec.push_back(std::move(obj)) — если obj больше не нужен.
• Обмен значениями: std::swap(a, b) внутри использует move.

Когда НЕ использовать std::move()?

• После перемещения объект в "пустом" состоянии. Если вы попытаетесь использовать его как обычно — UB (неопределённое поведение).
• Для маленьких объектов (int, char, маленькие POD-типы) — копирование быстрее перемещения.
• С const-объектами: std::move(const_obj) не сработает, так как перемещение требует модификации источника.
• Когда нужна гарантия, что источник останется неизменным.

Практический пример с вектором

std::vector<std::string> words;
std::string big = "очень длинная строка...";

words.push_back(big);           // Копирование (big остаётся)
words.push_back(std::move(big)); // Перемещение (big теперь пустая)
// После move big.size() == 0, big.empty() == true

// Можно повторно использовать big:
big = "новая строка";  // OK

Золотое правило

Используйте std::move() когда:

• Вы уверены, что исходный объект больше не нужен в текущем состоянии.
• Вы хотите оптимизировать производительность, избегая лишних копирований больших данных.
• Вы работаете с RAII-объектами (умные указатели, строки, контейнеры).

Помните: std::move() — это не магия, а инструмент для явного указания компилятору на возможность перемещения. Используйте его осознанно!

// Плохо: мешает RVO
std::string createString() {
    std::string s = "hello";
    return std::move(s); // Лучше просто: return s;
}

// Хорошо: явный move в сложных случаях
std::unique_ptr<int> createPtr() {
    auto ptr = std::make_unique<int>(42);
    // ... сложная логика ...
    return std::move(ptr); // OK, unique_ptr нельзя копировать
}