Понимание lvalue и rvalue в C и С++

Использовав std::move, мы говорим, что аргумент нам больше не нужен, и обязуемся не использовать его.
То есть использование объекта после передачи его в функцию — UB.

Начнём с того, что move semantics так называется не ради красного словца. Помимо решения технической проблемы (исключение излишнего копирования), язык предоставляет нам новую семантику, смысл, который мы вкладываем в такую передачу аргумента. Когда значение передаётся по неконстантной ссылке, подразумевается, что функция будет изменять объект и, таким образом, оказывать влияние «вовне», т.е. её результат будет виден в месте, откуда функция вызывалась. Но это не всегда нужно, поэтому существует и передача по значению, когда функция получает собственный экземпляр объекта, и все операции над ним снаружи не окажутся (конечно, если функция как-либо явно не вернёт этот объект).

До C++11 не было промежуточного варианта, когда мы и копировать не хотим, и «делиться» объектом тоже нежелательно. Что если нам «снаружи» объект уже не нужен, и мы хотим его просто передать внутрь «навсегда»? Конечно, можно передать по ссылке и, если объект был создан в пределах текущего скоупа, он автоматически будет уничтожен при выходе из него. Но передача по ссылке не несёт семантики поведения функции, при чтении такого кода неясно, можно ли дальше пользоваться переданным объектом или он был «испорчен» функцией (здесь «порча» понимается в терминах move semantics, т.е. содержимое объекта меняется, но его состояние остаётся допустимым для корректного уничтожения). Конечно, можно создать временную копию и передать ссылку на неё, но это пустая трата ресурсов. std::move() нужен для передачи объекта из рук в руки, он явно обозначает, что объект был перемещён, и далее в скоупе вызова им пользоваться нельзя, теперь им владеет вызванная функция, и она несёт за него ответственность.

Хорошим примером будет unique_ptr. По своему смыслу, это уникальный, существующий в одном экземпляре указатель на объект. Тем не менее, им можно «поделиться» с помощью передачи по ссылке, но нельзя скопировать, копирующий конструктор удалён. А вот перемещающий конструктор есть, и он очень интересный: при перемещении указателя вызывается release() на аргументе конструктора, что приводит к обнулению указателя в этом аргументе. Пример:

#include <iostream>
#include <memory>

using namespace std;

class A {

};

void foo(unique_ptr<A> p) {
    cout << "passed by value " << p.get() << endl;
}

int main(int argc, char* argv[]) {
    auto a = make_unique<A>();
    cout << "a was " << a.get() << endl;
    foo(move(a));
    cout << "a becomes " << a.get() << endl;
}

Выведет:

a was 0x555555a61290
passed by value 0x555555a61290
a becomes 0

Указатель переместился в функцию foo(), и снаружи неё его уже нельзя использовать! Использование std::move() явно говорит, что объект ушёл из этого скоупа куда-то дальше. Тут надо отметить, что если переписать сигнатуру foo как void foo(unique_ptr<A>&& p), то магия сломается, потому что перемещающий конструктор unique_ptr уже не вызовется, и для объекта такая передача будет полностью незаметна.

В целом, как и const, move semantics обозначает намерения программиста и обещания функций. Можно свести это в таблицу:

T — передача по значению, создастся копия, которая, возможно, будет меняться функцией; снаружи функции это не будет видно
T& — передача по ссылке, объект, возможно, будет меняться функцией, и это будет видно снаружи
const T& — передача по константной ссылке, объект не может меняться функцией (read-only доступ)
T&& — передача по rvalue-ссылке, объект может меняться функцией, снаружи объект перестаёт существовать (или следует считать так, даже если он являлся lvalue и был перемещён с помощью std::move), копия не создаётся

Несколько хороших примеров о приёме по значению и по rvalue-ссылке, а также применение std::move() есть в этом вопросе на StackOverflow, не всё так однозначно и чаще упирается в логику и намерения разработчика, чем в какие-то технические вопросы.