Стенли Липпман - Язык программирования C++. Пятое издание

Параметру функции, являющемуся ссылкой на r-значение на тип параметра шаблона (т.е. Т&&), может быть передан аргумент любого типа. Когда такому параметру передается l-значение, экземпляр параметра функции создается как обычная ссылка на l-значение ( T&).

У того факта, что параметр шаблона может быть выведен как ссылочный тип, имеются удивительные последствия для кода в шаблоне:

template void f3(Т&& val) {

T t = val; // копировать или привязать ссылку?

t = fcn(t); // изменит ли присвоение только t или val и t?

if (val == t) { /* ... */ } // всегда истинно, если Т - ссылочный тип

}

Когда вызов функции f3()происходит для такого r-значения, как литерал 42, Tимеет тип int. В данном случае локальная переменная tимеет тип intи инициализируется при копировании значения параметра val. При присвоении переменной t параметр valостается неизменным.

С другой стороны, когда происходит вызов функции f3()для l-значения i, типом Tбудет int&. Когда определяется и инициализируется локальная переменная t, у нее будет тип int&. Инициализация переменной tсвяжет ее с параметром val. При присвоении переменной tодновременно изменяется и параметр val. В этом экземпляре функции f3()оператор ifвсегда будет возвращать значение true.

На удивление сложно написать правильный код, когда задействованные типы могут быть простыми (не ссылочными) типами или ссылочными типами (хотя такие классы трансформации типов, как remove_reference(см. раздел 16.2.3), вполне могут помочь в этом).

На практике параметры в виде ссылки на r-значение используются в одном из двух случаев: либо когда шаблон перенаправляет свои аргументы, ли когда шаблон перегружается. Перенаправление рассматривается в разделе 16.2.7, а перегрузка шаблона в разделе 16.3, а пока достаточно знать, что стоит обратить внимание на то, что шаблоны функций, использующие ссылки на r-значение, зачастую используют перегрузку таким же образом, как описано в разделе 13.6.3:

template void f(Т&&); // привязка к не константным

// r-значениям

template void f(const T&); // l-значения и константные

// r-значения

Подобно нешаблонным функциям, первая версия будет связана с изменяемым r-значением, а вторая с l-значением или константным r-значением.

Упражнение 16.42. Определите типы Ти valв каждом из следующих вызовов:

template void g(T&& val);

int i = 0; const int ci = i;

(a) g(i); (b) g(ci); (c) g(i * ci);

Упражнение 16.43. Используя определенную в предыдущем упражнении функцию, укажите, каким будет параметр шаблона g() при вызове g(i = ci)?

Упражнение 16.44. Используя те же три вызова, что и в первом упражнении, определите типы T, если параметр функции g()объявляется как T(а не Т&&) и как const Т&?

Упражнение 16.45. С учетом следующего шаблона объясните происходящее при вызове функции g()с таким литеральным значением, как 42, и с переменной типа int?

template void g(T&& val) { vector v; }

Библиотечная функция move()(см. раздел 13.6.1) — хороший пример шаблона, использующего ссылки на r-значение. К счастью, функцию move()можно использовать, не понимая механизма работы используемого ею шаблона. Однако изучение работы функции move()может помочь понять и использовать шаблоны.

В разделе 13.6.2 обращалось внимание на то, что, хотя и нельзя непосредственно привязать ссылку на r-значение к l-значению, функцию move()можно использовать для получения ссылки на r-значение, связанной с l-значением. Поскольку функция move()может получать аргументы, по существу, любого типа, нет ничего удивительного в том, что move()— это шаблон функции.

Стандартное определение функции move()таково:

// об использовании typename в типе возвращаемого значения и

// приведении см. раздел 16.1.3

// remove_reference рассматривается в разделе 16.2.3

template

typename remove_reference::type&& move(T&& t) {

// static_cast рассматривается в разделе 4.11.3

return static_cast::type&&>(t);

}

Этот код короток, но сложен. В первую очередь, параметр функции move(), Т&&является ссылкой на r-значение типа параметра шаблона. Благодаря сворачиванию ссылок этот параметр может соответствовать аргументу любого типа. В частности, функции move()можно передать либо l-, либо r-значение:

string s1("hi!"), s2;

s2 = std::move(string("bye!")); // ok: перемещение r-значения

s2 = std::move(s1); // ok: но после присвоения

// значение s1 неопределенно

В первом присвоении аргумент функции move()является r-значением, полученным в результате выполнения конструктора string("bye")класса string. Как уже упоминалось, при передаче r-значения ссылочному r-значению параметра функции выведенный из этого аргумента тип является ссылочным типом (см. раздел 16.2.5). Таким образом, в вызове std::move(string("bye!")):

• выведенным типом Tбудет string;

• следовательно, экземпляр шаблона remove_referenceсоздается с типом string;

• тип-член typeкласса remove_referenceбудет иметь тип string;

• типом возвращаемого значения функции move()будет string&&;

• у параметра tфункции move()будет тип string&&;

Соответственно, этот вызов создает экземпляр move, являющийся следующей функцией:

string&& move(string &&t)

Тело этой функции возвращает тип static_cast(t). Типом tуже является string&&, поэтому приведение не делает ничего. Следовательно, результатом этого вызова будет ссылка на r-значение, которое было дано.

Теперь рассмотрим второе присвоение, которое вызывает функцию std::move(s1). В этом вызове аргументом функции move()является l-значение. Поэтому на сей раз:

• выведенным типом Тбудет string&(ссылка на тип string, а не просто string);

• следовательно, экземпляр шаблона remove_referenceсоздается с типом string&;

• тип-член typeкласса remove_referenceбудет иметь тип string;

• типом возвращаемого значения функции move()все еще будет string&&;

• параметр tфункции move()будет создан как экземпляр string& &&, который сворачивается в string&.