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

void process(Widget&& rvalArg); // Обработка rvalue

template // шаблон, передающий

void logAndProcess( T&& param) // param на обработку

{

auto now = // Получает текущее время

std::chrono::system_clock::now();

makeLogEntry("Bызoв 'process'", now);

process( std::forward(param));

}

Рассмотрим два вызова logAndProcess, один с lvalue, а другой — с rvalue:

Widget w;

logAndProcess(w); // Вызов с lvalue

logAndProcess(std::move(w)); // Вызов с rvalue

В функции logAndProcessпараметр paramпередается функции process. Функция processперегружена для lvalue и rvalue. Вызывая logAndProcessс lvalue, мы, естественно, ожидаем, что lvalue будет передано функции processкак lvalue, а вызывая logAndProcessс rvalue, мы ожидаем, что будет вызвана перегрузка processдля rvalue.

Однако param, как и все параметры функций, является lvalue. Каждый вызов processвнутри logAndProcessбудет, таким образом, вызывать перегрузку processдля lvalue. Для предотвращения такого поведения нам нужен механизм для приведения paramк rvalue тогда и только тогда, когда аргумент, которым инициализируется param — аргумент, переданный logAndProcess, — был rvalue. Именно этим и занимается std::forward. Вот почему std::forwardпредставляет собой условное приведение: эта функция выполняет приведение к rvalue только тогда, когда ее аргумент инициализирован rvalue.

Вы можете удивиться, откуда std::forwardможет знать, был ли ее аргумент инициализирован rvalue? Например, как в приведенном выше коде std::forwardможет сказать, был ли paramинициализирован с помощью lvalue или rvalue? Краткий ответ заключается в том, что эта информация кодируется в параметре Tшаблона logAndProcess. Этот параметр передается std::forward,которая восстанавливает закодированную информацию. Детальное описание того, как работает данный механизм, вы найдете в разделе 5.6.

Учитывая, что и std::move, и std::forwardсводятся к приведению и единственная разница между ними лишь в том, что std::moveвсегда выполняет приведение, в то время как std::forward— только иногда, вы можете спросить, не можем ли мы обойтись без std::moveи просто использовать везде std::forward. С чисто технической точки зрения ответ утвердительный: std::forwardможет сделать все. Необходимости в std::moveнет. Конечно, ни одна из этих функций не является действительно необходимой , потому что мы могли бы просто вручную написать требуемое приведение, но, я надеюсь, мы сойдемся во мнении, что это будет как минимум некрасиво.

Привлекательными сторонами std::moveявляются удобство, снижение вероятности ошибок и большая ясность. Рассмотрим класс, в котором мы хотели бы отслеживать количество вызовов перемещающего конструктора. Все, что нам надо, — это счетчик, объявленный как static, который увеличивался бы при каждом вызове перемещающего конструктора. Полагая, что единственными нестатическими данными класса является std::string, вот как выглядит обычный (т.e. использующий std::move) способ реализации перемещающего конструктора:

class Widget {

public:

Widget(Widget&& rhs)

: s( std::move(rhs.s))

{ ++moveCtorCalls; }

…

private:

static std::size_t moveCtorCalls;

std::string s;

};

Чтобы реализовать то же поведение с помощью std::forward, код должен был бы выглядеть следующим образом:

class Widget {

public:

Widget(Widget&& rhs) // Безусловная,

: s( std::forward(rhs.s)) // нежелательная

{ ++moveCtorCalls; } // реализация

…

};

Заметим сначала, что std::moveтребует только аргумент функции ( rhs.s), в то время как std::forwardтребует как аргумент функции ( rhs.s), так и аргумент типа шаблона ( std::string). Затем обратим внимание на то, что тип, который мы передаем std::forward, должен быть не ссылочным, поскольку таково соглашение по кодированию, что передаваемый аргумент является rvalue (см. раздел 5.6). Вместе это означает, что std::moveтребует меньшего ввода текста по сравнению с std::forwardи избавляет от проблем передачи типа аргумента, указывающего, что передаваемый аргумент является rvalue. std::moveустраняет также возможность передачи неверного типа (например, std::string&, что привело бы к тому, что член-данные sбыл бы создан с помощью копирования, а не перемещения).

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

• std::moveвыполняет безусловное приведение к rvalue. Сама по себе эта функция не перемещает ничего.

• std::forwardприводит свой аргумент к rvalue только тогда, когда этот аргумент связан с rvalue.

• Ни std::move, ни std:: forwardне выполняют никаких действий времени выполнения.

Говорят, что истина делает нас свободными, но при соответствующих обстоятельствах хорошо выбранная ложь может оказаться столь же освобождающей. Этот раздел и есть такой ложью. Но поскольку мы имеем дело с программным обеспечением, давайте избегать слова “ложь”, а вместо него говорить, что данный раздел содержит “абстракцию”.

Чтобы объявить rvalue-ссылку на некоторый тип T, вы пишете T&&. Таким образом, представляется разумным предположить, что если вы видите в исходном тексте T&&, то имеете дело с rvalue-ссылками. Увы, не все так просто.

void f(Widget &&param); // rvalue-ссылка

Widget &&var1 = Widget(); // rvalue-ссылка

auto &&var2 = var1; // Не rvalue-ссылка

template

void f(std::vector &&param); // rvalue-ссылка

template

void f(T &&param); // Не rvalue-ссылка

На самом деле “ T&&” имеет два разных значения. Одно из них — конечно, rvalue-ссылка. Такие ссылки ведут себя именно так, как вы ожидаете: они связываются только с rvalue и их смысл заключается в идентификации объектов, которые могут быть перемещены.

Другое значение “ T&&” — либо rvalue-ссылка, либо lvalue-ссылка. Такие ссылки выглядят в исходном тексте как rvalue-ссылки (т.e. “ T&&”), но могут вести себя так, как если бы они были lvalue-ссылками (т.e. “ T&”). Такая дуальная природа позволяет им быть связанными как с rvalue (подобно rvalue-ссылкам), так и с lvalue (подобно lvalue-ссылкам). Кроме того, они могут быть связаны как с константными, так и с неконстантными объектами, как с объектами volatile, так и с объектами, не являющимися volatile, и даже с объектами, одновременно являющимися и const, и volatile. Они могут быть связаны практически со всем . Такие беспрецедентно гибкие ссылки заслуживают собственного имени, и я называю их универсальными ссылками [16] В разделе 5.3 поясняется, что к универсальным ссылкам почти всегда может применяться std::forward , так что, когда эта книга готовилась к печати, некоторые члены сообщества С++ начинали именовать универсальные ссылки передаваемыми ссылками . .