Move-семантика

Move-конструктор принимает rvalue-ссылку, T(T&&), а copy-конструктор — const lvalue-ссылку, T(const T&). Именно параметр T&& заставляет выбирать move-конструктор для rvalue, и его обычно помечают noexcept.

rvalue — категория значения, обычно временное выражение. rvalue-ссылка — тип вида T&&, способный привязываться к rvalue. Именованная переменная типа T&& внутри своей области видимости остаётся lvalue-выражением.

Копирование дублирует владеемый ресурс, оставляя источник нетронутым и создавая два независимых объекта. Move передаёт владение существующим ресурсом приёмнику и оставляет источник в валидном, но неопределённом состоянии.

std::move ничего не делает во время выполнения — это лишь приведение аргумента к rvalue-ссылке (T&&) на этапе компиляции. Он не перемещает данные; реальный move происходит позже и только если затем выбран move-конструктор или move-присваивание.

std::move безусловно приводит выражение к rvalue-ссылке. std::forward<T> условно сохраняет исходную категорию значения в шаблонах с forwarding reference.

Когда вы делаете return локальной переменной по значению, компилятор трактует эту локальную как rvalue и автоматически выбирает move-конструктор — std::move не нужен. Запись return std::move(local) вредна: она пессимизирует, блокируя copy elision (NRVO).

unique_ptr — эксклюзивное владение; copy дал бы двух владельцев и double-delete. Copy удалены, move определены. Передача: unique_ptr<T> по значению (вызывающий std::move'ит) или unique_ptr<T>&&. Для заимствования — T&/const T&. Возврат — move через RVO.

После move объект валиден, но неопределён — можно уничтожить, присвоить, вызвать операции без предусловий (clear(), empty()), но полагаться на значение нельзя. Стандартные типы обычно пусты по конвенции, не по гарантии.

Пишите Derived(Derived&& o) noexcept : Base(std::move(o)), m_(std::move(o.m_)) {}. std::move(o) обязателен — o lvalue в теле, без move выберется copy-ctor Base. В move-assign: Base::operator=(std::move(o));, затем члены.

Copy elision конструирует возврат прямо в хранилище вызывающего, пропуская copy/move-ctor. RVO — для временных (обязателен с C++17 для prvalue); NRVO — для именованных локальных (опционально). При обязательном RVO T x = f(); вызывает один ctor.

Удалённый move-ctor участвует в overload resolution (объявлен, просто удалён) и выбирается как лучшее совпадение для rvalue — становится hard compile error. T x = std::move(y); не компилируется, а не молча падает в copy-ctor.

Неявно генерируется только если ни один из (dtor, copy ctor/assign, move ctor/assign) не объявлен пользователем, и все члены/базовые классы перемещаемы. Объявление любой из них подавляет неявный move — класс падает в copy.

std::move(x) возвращает static_cast<remove_reference_t<T>&&>(x) — для const T это const T&&. Move-ctor берёт T&& (не const), поэтому overload resolution падает на copy-ctor (const T&). Молчаливое copy, ошибки нет.

Вместо перегрузок set(const T&) и set(T&&) пишите set(T x) { m_ = std::move(x); }. Параметр строится один раз: copy из lvalue, move из rvalue. Тело всегда move'ит в член. Цена — один дешёвый move; плюс — вдвое меньше перегрузок.

Self-move (x = std::move(x)) редок, но возможен. Moved-from остаётся «валидным, но неопределённым», так что no-op допустим. Copy-and-swap безопасен сам; ручной перенос требует if (this != &other) или порядка release-до-acquire.

Объявление move-конструктора или move-присваивания подавляет неявную генерацию copy-операций — они становятся удалёнными, если не задать явно или = default. Правило симметрично: объявление copy-операций подавляет неявный move.

Типы, чьё представление целиком value-based без владения heap-ресурсом: int, double, маленькие POD-структуры, std::array<T, N> тривиальных T. Для них move идентичен copy, потому что красть нечего.

Нет. Встроенный массив — часть хранилища объекта, поэтому сгенерированное перемещение поэлементно move'ит/копирует каждый элемент. Move дёшев только когда объект передаёт внешний ресурс — например указатель на heap-буфер без касания данных.

Rule of Zero: если все члены сами управляют ресурсами (контейнеры, smart pointers, RAII), не определяйте спецчлены. Rule of Five: если пришлось определить одну из пяти (dtor, copy ctor/assign, move ctor/assign), обдумайте все пять — ручное владение значит Rule of Five.

Вставки (push_back, emplace_back, insert) перемещают из rvalue. Реаллокация vector — move только при noexcept. Алгоритмы std::move, std::rotate, std::swap — move; std::copy, std::copy_n, std::transform — copy. Range-адаптеры C++20 — views::move.

Возвращает rvalue-ссылку, если move-ctor noexcept или у типа нет copy-ctor; иначе const lvalue-ссылку, и следующая конструкция копирует. Контейнеры применяют это при реаллокации ради strong exception guarantee.

vector::push_back даёт strong exception guarantee — если move бросит на середине реаллокации, vector не откатится. Поэтому std::move_if_noexcept: noexcept move → move, иначе → copy. Не-noexcept move молча превращается в copy.

return std::move(local) блокирует NRVO/RVO copy elision, потому что std::move(local) — уже не сам локальный объект, а rvalue-выражение на него. Без elision вы платите реальный move-вызов — дешевле copy, но не ноль.

Методы можно квалифицировать value category this: T m() & — на lvalue, T m() && — на rvalue. Полезно для разных тел — например Buffer::data() && move'ит хранилище, ведь объект умирает, а Buffer::data() const & возвращает лишь const-вид.

Если источник помещается в inline-буфер (SSO), move копирует inline-байты — heap-указателя для swap нет. «Move бесплатен» неверно для коротких строк; SSO-move по сути — copy. Длинные строки крадут heap-указатель (O(1)). Порог SSO разный (~15–23 байта).

std::vector при реаллокации использует move только если move-ctor noexcept (std::is_nothrow_move_constructible). Иначе copy ради strong exception guarantee: бросивший на середине move не откатить, copy оставит исходный буфер целым.