Существуют ли какие-либо реалистичные варианты использования переменных `decltype (auto)`?

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

Тот факт, что его также можно использовать для объявления переменных, не обязательно означает, что должны быть сценарии лучше, чем другие. Действительно, использование decltype(auto) в объявлении переменной просто усложнит чтение кода, учитывая, что для объявления переменной он имеет точно такое же значение. С другой стороны, форма auto&& позволяет объявлять постоянную переменную, а decltype(auto) - нет.

По сути, случай переменных такой же, как и для функций. Идея в том, что мы сохраняем результат вызова функции с переменной decltype(auto):

decltype(auto) result = /* function invocation */;

Тогда result

• не ссылочный тип, если результатом является prvalue,

• ссылочный тип lvalue (возможно, квалифицированный cv), если результатом является lvalue, или

• ссылочный тип rvalue, если результатом является xvalue.

Теперь нам нужна новая версия forward, чтобы различать регистр prvalue и случай xvalue: (имя forward избегается во избежание проблем с ADL)

template <typename T>
T my_forward(std::remove_reference_t<T>& arg)
{
    return std::forward<T>(arg);
}

А затем используйте

my_forward<decltype(result)>(result)

В отличие от std::forward, эта функция используется для пересылки decltype(auto) переменных. Следовательно, он не обязательно возвращает ссылочный тип, и предполагается, что он будет вызываться с decltype(variable), который может быть T, T& или T&&, чтобы он мог различать lvalues, xvalues ​​и prvalues. Таким образом, если result

• не ссылочный тип, то вторая перегрузка вызывается с не ссылочным T, и возвращается не ссылочный тип, что приводит к prvalue;

• ссылочный тип lvalue, тогда первая перегрузка вызывается с T&, и возвращается T&, что приводит к lvalue;

• ссылочный тип rvalue, затем вызывается вторая перегрузка с T&&, и возвращается T&&, в результате чего получается xvalue.

Вот пример. Учтите, что вы хотите обернуть std::invoke и что-то напечатать в журнале: (пример приведен только для иллюстрации)

template <typename F, typename... Args>
decltype(auto) my_invoke(F&& f, Args&&... args)
{
    decltype(auto) result = std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    my_log("invoke", result); // for illustration only
    return my_forward<decltype(result)>(result);
}

Теперь, если выражение вызова

• prvalue, тогда result - это не ссылочный тип, а функция возвращает не ссылочный тип;

• неконстантное lvalue, тогда result - неконстантная ссылка lvalue, и функция возвращает неконстантный ссылочный тип lvalue;

• const lvalue, тогда result - это ссылка на const lvalue, а функция возвращает ссылочный тип const lvalue;

• xvalue, тогда result - это ссылочный тип rvalue, а функция возвращает ссылочный тип rvalue.

Учитывая следующие функции:

int f();
int& g();
const int& h();
int&& i();

справедливы следующие утверждения:

static_assert(std::is_same_v<decltype(my_invoke(f)), int>);
static_assert(std::is_same_v<decltype(my_invoke(g)), int&>);
static_assert(std::is_same_v<decltype(my_invoke(h)), const int&>);
static_assert(std::is_same_v<decltype(my_invoke(i)), int&&>);

(живая демонстрация, переместить только тестовый пример)

Если вместо этого используется auto&&, у кода возникнут проблемы с различием между prvalues ​​и xvalues.