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

Надо сказать, что передача контейнера, являющегося rvalue, в authAndAccess является крайним случаем. Такой rvalue-контейнер, будучи временным объектом, обычно уничтожается в конце инструкции, содержащей вызов authAndAccess, а это означает, что ссылка на элемент в таком контейнере (то, что должна вернуть функция authAndAccess) окажется “висячей” в конце создавшей ее инструкции. Тем не менее передача временного объекта функции authAndAccess может иметь смысл. Например, клиент может просто хотеть сделать копию элемента во временном контейнере:

std::deque makeStringDeque(); // Фабричная функция

// Делаем копию пятого элемента deque, возвращаемого
// функцией makeStringDeque
auto s = authAndAccess(makeStringDeque(), 5);

Поддержка такого использования означает, что мы должны пересмотреть объявление функции authAndAccess, которая должна принимать как lvalue, так и rvalue. Можно использовать перегрузку (одна функция объявлена с параметром, представляющим собой lvalue-ссылку, а вторая — с параметром, представляющим собой rvalue-ссылку), но тогда нам придется поддерживать две функции. Избежать этого можно, если у нас будет функция authAndAccess, использующая ссылочный параметр, который может быть связан как с lvalue, так и с rvalue, и в разделе 5.2 поясняется, что это именно то, что делают универсальные ссылки. Таким образом, authAndAccess может быть объявлена следующим образом:

template // Теперь с -
decltype(auto) authAndAccess(Container&& с,  // универсальная
                             Index i);       // ссылка

В этом шаблоне мы не знаем, с каким типом контейнера работаем, и точно так же не знаем тип используемых им индексных объектов. Использование передачи по значению для объектов неизвестного типа обычно сопровождается риском снижения производительности из-за ненужного копирования, проблемами со срезкой объектов (см. раздел 8.1) и насмешками коллег. Но в случае индексов контейнеров, следуя примеру стандартной библиотеки для значений индексов (например, в operator[] для std::string, std::vector и std::deque) это решение представляется разумным, так что мы будем придерживаться для них передачи по значению.

Однако нам нужно обновить реализацию шаблона для приведения его в соответствие с предостережениями из раздела 5.3 о применении std::forward к универсальным ссылкам:

template // Окончательная
decltype(auto)                               // версия для
authAndAccess(Container&& с, Index i)        // С++14
{
 authenticateUser();
 return std::forward(c)[i];
}

Этот код должен делать все, что мы хотели, но он требует компилятора С++14. Если у вас нет такового, вам следует использовать версию шаблона для С++11. Она такая же, как и ее аналог С++14, за исключением того, что вы должны самостоятельно указать возвращаемый тип:

template // Окончательная
auto                                         // версия для
authAndAccess(Container&& с, Index i)        // C++11
 -> decltype(std::forward(с)[i]) {
 authenticateUser();
 return std::forward(с)[i]);
}

Вторым беспокоящим моментом является мое замечание в начале этого раздела о том, что decltypeпочти всегда дает тип, который вы ожидаете, т.е. что он редко преподносит сюрпризы. По правде говоря, вряд ли вы столкнетесь с этими исключениями из правила, если только вы не занимаетесь круглосуточно написанием библиотек.

Чтобы полностью понимать поведение decltype, вы должны познакомиться с некоторыми особыми случаями. Большинство из них слишком невразумительны, чтобы быть размещенными в этой книге, но один из них приводит к лучшему пониманию decltype и его применения.

Применение decltype к имени дает объявленный тип для этого имени. Имена представляют собой lvalue-выражения, но это не влияет на поведение decltype. Однако для lvalue-выражений, более сложных, чем имена, decltype гарантирует, что возвращаемый тип всегда будет lvalue-ссылкой. Иначе говоря, если lvalue-выражение, отличное от имени, имеет тип Т, то decltype сообщает об этом типе как об Т&. Это редко на что-то влияет, поскольку тип большинства lvalue-выражений в обязательном порядке включает квалификатор lvalue-ссылки. Например, функции, возвращающие lvalue, всегда возвращают lvalue-ссылки.

Однако у этого поведения есть следствия, о которых необходимо знать. В коде

int x = 0;

x является именем переменной, так что decltype(x) представляет собой int. Однако “заворачивание” имени x в скобки — “(x)” — дает выражение, более сложное, чем имя. Будучи именем, x представляет собой lvalue, и С++ также определяет выражение (x) как lvalue. Следовательно, decltype((x)) представляет собой int&. Добавление скобок вокруг имени может изменить тип, возвращаемый для него decltype!

В C++11 это просто любопытный факт, но в сочетании с поддержкой в С++14 decltype (auto) это означает, что, казалось бы, тривиальные изменения в способе записи инструкции return могут повлиять на выводимый тип функции:

decltype(auto) f1() {
 int x = 0;