Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [77]

:

Widget makeWidget() // "Копирующая" версия makeWidget
{
 Widget w;
 …
 return w;          // "Копирование" w в возвращаемое значение
)

Здесь выполняются оба условия, и вы можете доверять мне, когда я говорю вам, что каждый приличный компилятор С++ будет использовать RVO для того, чтобы избежать копирования w. Это означает, что “копирующая” версия makeWidget на самом деле копирования не выполняет.

Перемещающая версия makeWidget делает только то, о чем говорит ее имя (в предположении наличия перемещающего конструктора Widget): она перемещает содержимое w в местоположение возвращаемого значения makeWidget. Но почему компиляторы не используют RVO для устранения перемещения, вновь создавая w в памяти, выделенной для возвращаемого значения функции? Ответ прост: они не могут. Условие (2) предусматривает, что RVO может быть выполнена, только если возвращается локальный объект, но в перемещающей версии makeWidget это не так. Посмотрим еще раз на инструкцию return:

return std::move(w);

То, что здесь возвращается, не является локальным объектом w; это ссылка наw — результат std::move(w). Возврат ссылки на локальный объект не удовлетворяет условиям, требующимся для применения RVO, так что компиляторы вынуждены перемещать w в местоположение возвращаемого значения функции. Разработчики, пытаясь с помощью применения std::move к возвращаемой локальной переменной помочь компиляторам оптимизировать код, на самом деле ограничивают возможности оптимизации, доступные их компиляторам!

Но RVO — это всего лишь оптимизация. Компиляторы не обязаны устранять операции копирования и перемещения даже тогда, когда это им позволено. Возможно, вы параноик и беспокоитесь о том, что ваши компиляторы будут выполнять операции копирования, просто потому, что они могут это делать. А может, вы настолько глубоко разбираетесь в ситуации, что в состоянии распознать случаи, когда компиляторам трудно применять RVO, например когда различные пути выполнения в функции возвращают разные локальные переменные. (Компиляторы должны генерировать код для построения соответствующей локальной переменной в памяти, выделенной для возвращаемого значения функции, но как компиляторы смогут определить, какая локальная переменная должна использоваться?) В таком случае вы можете быть готовы заплатить цену перемещения как гарантию того, что копирование выполнено не будет. Иначе говоря, вы можете продолжать думать, что применение std::move к возвращаемому локальному объекту разумно просто потому, что при этом вы спокойны, зная, что вам не придется платить за копирование.

В этом случае применение std::move к локальному объекту все равно остается плохой идеей. Часть стандарта, разрешающая применение RVO, гласит далее, что если условия для применения RVO выполнены, но компиляторы предпочитают не выполнять удаление копирования, то возвращаемый объект должен рассматриваться как rvalue. По сути, стандарт требует, чтобы, когда оптимизация RVO разрешена, к возвращаемому локальному объекту либо применялось удаление копирования, либо неявно применялась функция std::move. Так что в “копирующей” версии makeWidget

Widget makeWidget() // Как и ранее
{
 Widget w;
 …
 return w;
}

компиляторы должны либо устранить копирование w, либо рассматривать функцию, как если бы она была написана следующим образом:

Widget makeWidget() {
 Widget w;
 …
 return std::move(w); // Рассматривает w как rvalue, поскольку
}                     // удаление копирования не выполняется

Ситуация аналогична для параметров функции, передаваемых по значению. Они не имеют права на удаление копирования при их возврате из функции, но компиляторы должны рассматривать их в случае возврата как rvalue. В результате, если ваш исходный текст выглядит как

Widget makeWidget(Widget w) // Передаваемый по значению параметр
{                           // имеет тот же тип, что и
 …                          // возвращаемый тип функции
 return w;
}

компиляторы должны рассматривать его, как если бы он был написан как

Widget makeWidget(Widget w) {
 return std::move(w); // w рассматривается как rvalue
}

Это означает, что, используя std::move для локального объекта, возвращаемого функцией по значению, вы не можете помочь компилятору (он обязан рассматривать локальный объект как rvalue, если не выполняет удаления копирования), но вы, определенно, в состоянии ему помешать (препятствуя RVO). Есть ситуации, когда применение std::move к локальной переменной может быть разумным (т.e. когда вы передаете ее функции и знаете, что больше вы ее использовать не будете), но эти ситуации не включают применение std::move в качестве части инструкции return, которая в противном случае претендовала бы на оптимизацию RVO, или возврат параметра, передаваемого по значению.

Следует запомнить

• Применяйте std::move к rvalue-ссылкам, а std::forward — к универсальным ссылкам, когда вы используете их в последний раз.

• Делайте то же для rvalue- и универсальных ссылок, возвращаемых из функций по значению.

• Никогда не применяйте std::move и std::forward к локальным объектам, которые могут быть объектом оптимизации возвращаемого значения.