Почему вы используете std :: move, когда у вас есть && в C ++ 11?

Во-первых, вероятно, в вопросе, который я рассмотрю, есть заблуждение:
Когда вы видите T&& t в коде (а T - это фактический тип, а не тип шаблона), имейте в виду, что категория значений t - это lvalue (ссылка ), а не rvalue (временное). Это очень сбивает с толку. T&& просто означает, что t построен из объекта, который был rvalue ¹, но t сам является lvalue, а не rvalue. Если у него есть имя (в данном случае t), то это lvalue и не будет автоматически перемещаться, но если у него нет имени (результат 3+4), то это rvalue и будет автоматически перейти к его результату, если может. Тип (в данном случае T&&) почти не имеет ничего общего с категорией значения переменной (в данном случае lvalue).

При этом, если в вашем коде написано T&& t, это означает, что у вас есть ссылка на переменную, которая была временной, и ее можно уничтожить, если вы хотите. Если вам нужно обращаться к переменной несколько раз, вы не хотите std::move из нее, иначе она потеряет свое значение. Но в последний раз, когда вы переходите t, безопасно std::move это значение для другого T, если хотите. (И в 95% случаев это то, что вы хотите делать). Все это относится и к auto&& переменным.

^{1. если T - тип шаблона, T&& - это ссылка переадресации, и в этом случае вы используете std::forward<T>(t) вместо std::move(t) в последний раз. См. этот вопрос.}

Я нашел эту статью, чтобы дать достаточно информации о ссылках на rvalue в целом. Он упоминает std::move ближе к концу. Это, наверное, самая актуальная цитата:

Нам нужно использовать std::move, от <utility> - std::move - это способ сказать: «Хорошо, честно говоря, я знаю, что у меня есть lvalue, но я хочу, чтобы это было rvalue». std::move сам по себе ничего не перемещает; он просто превращает lvalue в rvalue, чтобы вы могли вызвать конструктор перемещения.

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

MyClass::MyClass(MyClass&& other): myMember(other.myMember)
{
    // Whatever else.
}

Когда вы используете оператор other.myMember, возвращается значение lvalue. Таким образом, код использует конструктор copy для инициализации this->myMember. Но поскольку это конструктор перемещения, мы знаем, что other - временный объект, а значит, и его члены. Поэтому мы действительно хотим использовать более эффективный конструктор move для инициализации this->myMember. Использование std::move гарантирует, что компилятор рассматривает other.myMember как ссылку rvalue и вызывает конструктор перемещения, как вы хотите:

MyClass::MyClass(MyClass&& other): myMember(std::move(other.myMember))
{
    // Whatever else.
}

Только не используйте std::move на объектах, которые вам нужно держать рядом - конструкторы перемещения практически гарантированно уничтожат любые переданные в них объекты. Вот почему они используются только с временными конструкциями.

Надеюсь, это поможет!

Когда у вас есть объект типа T&&, rvalue, это означает, что этот объект можно безопасно перемещать, так как никто больше не будет зависеть от его внутреннего состояния позже.

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

Когда следует избегать std::move, даже если это будет безопасно? Я бы не стал использовать его в тривиальных примерах, например:

 int x = 0;
 int y = std::move(x);

В остальном я не вижу минусов. Если это не усложняет код, перемещение надо делать по возможности ИМХО.

Другой пример, куда вы не хотите переходить, - это возвращаемые значения. Язык гарантирует, что возвращаемые значения (по крайней мере) перемещаются, поэтому вам не следует писать

return std::move(x); // not recommended

(Если вам повезет, сработает оптимизация возвращаемого значения, что даже лучше, чем операция перемещения.)

Вы можете использовать move, когда вам нужно «перенести» содержимое объекта в другое место без копирования. Также возможно, что объект получит содержимое временного объекта без копирования, с помощью std :: move.

Проверить эту ссылку