Как выполнить идеальную пересылку, когда аргумент шаблона явно объявлен

Есть ли способ написать функцию mkVector так, чтобы она корректно работала во всех возможных случаях, поддерживая идеальную переадресацию?

Нет, нет. Вы можете либо использовать ссылку для пересылки и по прихоти пользователя предоставить поддельный U, либо реализовать все функции std::forward внутри mkVector. Для этого вам понадобится как минимум две перегрузки, так что вы на правильном пути, но я бы не стал развивать эту идею дальше; это пустая трата времени.

Реальная проблема здесь заключается в том, что пользователь может что-то сломать, предоставив явные аргументы шаблона, и эта проблема не ограничивается простой переадресацией. Рассмотрим следующий пример:

template <typename T>
void f(T x) {
    use(std::move(x));
}

Если бы пользователь вызвал f<U&>(u) явно, то f переместился бы из заданного u, а не из локальной копии. Существует множество стандартных библиотечных функций, которые также не реализованы таким образом, чтобы обеспечить устойчивость к явным аргументам (например, std::swap). Это действительно основная проблема C++, которая гораздо более распространена, чем можно подумать.

Итак... что нам с этим делать? У вас есть два варианта:

• Плевать. mkVector не следует использовать с явными аргументами, и виноват пользователь, если он использует его таким образом.
• Не позволяйте пользователю явно передавать что-либо (полезное).

Для последнего подхода вы можете написать:

template <typename..., typename U>
auto mkVector(U&& x0)
{
    return std::vector<std::decay_t<U>>{std::forward<U>(x0)};
}

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

В идеале вам нужно что-то вроде этого:

template <typename T = std::decay_t<U>, typename U>
auto mkVector(U&& x0) {
    return std::vector<T>{std::forward<U>(x0)};
}

... Где T по умолчанию равен std::decay_t<U>, если не указано явно. Однако это не работает, поскольку по умолчанию нельзя ссылаться на более поздний аргумент.

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

template<typename T = void, typename U>
auto mkVector(U&& x0) {
    using type = std::conditional_t<std::is_void_v<T>, std::decay_t<U>, T>;
    return std::vector<type>{ std::forward<U>(x0) };
}

Я не знаю, что вы подразумеваете под «потребуется 2^N возможных перегрузок». Если бы у вас было больше аргументов, вы не могли бы явно указать второй аргумент, не указав явно первый, поэтому вам потребовалось бы максимум N+1 перегрузок. Для нескольких аргументов вы можете сделать что-то вроде этого:

namespace detail {
template<std::size_t N, typename Default, typename... Types>
auto nth_or_impl() {
    if constexpr (sizeof...(Types) > N) {
        return std::tuple_element<N, std::tuple<Types...>>{};
    } else {
        return std::enable_if<true, Default>{};
    }
}
}

template<std::size_t N, typename Default, typename... Types>
using nth_or = typename decltype(detail::nth_or_impl<N, Default, Types...>)_)::type;

template <typename... T, typename U0, typename U1, typename U2>
auto f(U0&& x0, U1&& u1, U2&& u2) {
    static_assert(sizeof...(T) <= 3, "f: Explicitly specified more than 3 template arguments");
    using T1 = nth_or<0, std::decay_t<U0>, T...>;
    using T2 = nth_or<1, std::decay_t<U1>, T...>;
    using T3 = nth_or<2, std::decay_t<U2>, T...>;
    // ...
}

Это также поддерживает пакеты параметров неизвестного размера.

template<class T, class U>
concept compatible = std::is_convertible_v<T, std::decay_t<U>> || std::is_void_v<U>;

template<class X, class Alt>
using fallback_t = std::conditional_t<std::is_void_v<X>, Alt, X>;

template <class T = void, compatible<T> U>
auto mkVector(U&& x0) {
  using V = fallback_t< T, std::decay_t<U> >;
  return std::vector<V>{std::forward<U>(x0)};
}

Это создает фабричную функцию mkVector. При желании можно передать тип T. Если ему передается тип T, он создает вектор этого типа и гарантирует, что ваш аргумент может быть сохранен в векторе этого типа.

Отсутствие совместимости приводит к ошибке разрешения перегрузки из-за несоответствия концепции.

В противном случае создается вектор std::decay_t<U>, где U — тип переданного значения.

Это легко масштабируется до большего количества аргументов, не требуя ручной реализации 2^n. Например

template<class K=void, class V=void, compatible<K>, Ku, compatible<V> Vu>
auto mkMap( Ku&& k, Vu&& v ) {
  using Km = fallback_t< K, std::decay_t<Ku> >;
  using Vm = fallback_t< V, std::decay_t<Vu> >;
  return std::map< Km, Vm >( { std::forward<Ku>(k), std::forward<Vu>(v) } );
}

с линейным кодом, а не с экспоненциальным кодом.