Как да напиша функция с променлив шаблон в C++, където пакетът с параметри не е последният параметър?

Предлагам друго решение, наистина различно от кода във въпроса, което според мен е много по-ефективно (създаване само на един std::array; блендер, получен чрез последователност от индекси на шаблони)

#include <array>
#include <utility>
#include <iostream>

template <typename T, std::size_t I0>
int blenderH (double t, T const & arr, std::index_sequence<I0> const &)
 { return arr[I0]; }

template <typename T, std::size_t I0, std::size_t ... Is>
auto blenderH (double t, T const & arr, 
               std::index_sequence<I0, Is...> const &)
   -> std::enable_if_t<0U != sizeof...(Is), int>
 { return   (1-t) * blenderH(t, arr, std::index_sequence<(Is-1U)...>{})
          +    t  * blenderH(t, arr, std::index_sequence<Is...>{}); }

template <typename ... Args>
int blender (double t, Args ... as)
 {
   static constexpr auto size = sizeof...(Args);

   return blenderH(t, std::array<int, size>{ { as... } },
                   std::make_index_sequence<size>{});
 }

int main()
 { std::cout << blender(.3, 23, 42, 89) << std::endl; }

За съжаление и това решение работи (std::index_sequence и std::make_index_sequence), като се започне от C++14.

-- РЕДАКТИРАНЕ --

Калет казва.

Някакво обяснение на случващото се тук би помогнало. Объркан съм от липсата на I0 в тялото на второто претоварване.

Опитвам се с обяснение.

Да предположим, че се нарича рекурсивна версия на BlenderH() (второто претоварване) със списък от индекси в стойността std::index_sequence. Кажете 5, 6, 7 и 8; така че I0 е 5 и Is... е 6, 7, 8.

Трябва да извикаме рекурсивно blenderH() с индекси 5, 6, 7 първо и с 6, 7, 8 следващо.

Можем да избегнем използването на I0 (5), защото

• 5, 6, 7 се получава от 6, 7, 8 намаляване с 1 на всяка стойност (така че std::index_sequence<(Is-1U)...> за първото рекурсивно повикване)

• и 6, 7, 8 е Is... без модификации (така че std::index_sequence<Is...> във втория.

От практическа гледна точка I0 се обявява само за изхвърляне; няма нужда да го използвате.

template<std::size_t I>
using count = std::integral_constant<std::size_t, I>;

namespace details {

  template<class...Args, std::size_t N,
    typename std::enable_if<sizeof...(Args)==N, bool>::type = true
  >
  int Blender( count<N> drop, double t, int i, Args...args ) {
    return i;
  }
  template<class...Args, std::size_t N,
    typename std::enable_if<sizeof...(Args)!=N, bool>::type = true
  >
  int Blender( count<N> drop, double t, int i, Args...args ) {
    return (1-t)*Blender( count<N+1>{}, t, i, args... ) + t*Blender( count<N>{}, t, args... );
  }
}

template <typename ...Args>
int Blender( double t, int first, Args... more)
{
  return details::Blender( count<0>{}, first, more... );
}


static void tryit()
{
  Blender(.5, 23, 42, 89); //doesn't compile
}

тук count<N> брои броя на аргументите в края, които да се игнорират.

Двете details претоварвания покриват случая, когато N е равно на броя на аргументите в пакета (и следователно ни остава 1 аргумент), и когато не е. Те се изпращат с помощта на SFINAE.

Това всъщност е много лесно, след като осъзнаете, че ограничението е в извеждането на пакета тип, а не в извикването на функция. Просто се нуждаем от начин да използваме пакета типове, който можем да изведем и да го предадем изрично, избягвайки дедукцията във функцията, която трябва да извлече последния параметър:

int Blender( double t, int i)
{
    return i;
}

template <typename ...Args>
  int Blender( double t, int first, Args... more);

template <typename ...Args>
  int BlenderWithoutLast( double t, Args... more, int last)
{
    return Blender(t, more...);
}

template <typename ...Args>
  int Blender( double t, int first, Args... more)
{
    return (1-t)*BlenderWithoutLast<Args...>(t, first, more...) + t*Blender(t, more...);
    //    all the magic happens here ^^^^^
}

и сега вашият тестов случай се компилира и изпълнява

#include <iostream>
int main()
{
    std::cout << Blender(.5, 23, 42, 89);
}

За мен това работи с clang и --std=c++11