Функция с двумя переменными параметрами

Не уверен, что понимаю, чего вы хотите, но я полагаю, вам нужно использовать std::tuple (или что-то подобное) для разделения двух последовательностей аргументов.

Ниже приведен полный рабочий пример того, что я имею в виду, в соответствии с тем, что я понимаю, чего вы хотите.

#include <tuple>
#include <string>
#include <utility>
#include <iostream>
#include <functional>

template <typename T1, typename T2, typename T3, typename T4,
          typename ... Ts1, typename ... Ts2,
          std::size_t ... Is1, std::size_t ... Is2>
auto myWrapperH (T3 func1, T4 func2, std::tuple<Ts1...> const & tp1,
                 std::tuple<Ts2...> const & tp2,
                 std::index_sequence<Is1...> const &,
                 std::index_sequence<Is2...> const &)
 {
   T1 f1 = std::bind(func1, std::get<Is1>(tp1)...);
   T2 f2 = std::bind(func2, std::get<Is2>(tp2)...);

   return std::make_pair(f1, f2);
 }

template <typename T1, typename T2, typename T3, typename T4,
          typename ... Ts1, typename ... Ts2>
auto myWrapper (T3 func1, T4 func2, std::tuple<Ts1...> const & tp1,
                std::tuple<Ts2...> const & tp2)
 { return myWrapperH<T1, T2>(func1, func2, tp1, tp2,
                             std::make_index_sequence<sizeof...(Ts1)>{},
                             std::make_index_sequence<sizeof...(Ts2)>{}); }

int foo (int a, int b)
 { return a+b; }

std::size_t bar (int a, int b, std::string const & str)
 { return str.size() + a + b; }

int main ()
 {
   using fType1 = std::function<int(int)>;
   using fType2 = std::function<long()>;

   auto mwr = myWrapper<fType1, fType2>(&foo, &bar,
                 std::make_tuple(1, std::placeholders::_1),
                 std::make_tuple(110, 20, std::string{"something"}));

   std::cout << mwr.first(5) << std::endl; // print   6
   std::cout << mwr.second() << std::endl; // print 139
 }

К сожалению, это код C++14 (тип возврата auto; std::index_sequence и std::make_index_sequence), но его легко адаптировать в C++11.

-- ИЗМЕНИТЬ--

Как указал Банан (спасибо!), нет необходимости явно указывать тип возвращаемых функций (T1, T2).

Используя тип возвращаемого значения auto, пример можно упростить следующим образом.

#include <tuple>
#include <string>
#include <utility>
#include <iostream>
#include <functional>

template <typename F1, typename F2, typename ... Ts1, typename ... Ts2,
          std::size_t ... Is1, std::size_t ... Is2>
auto myWrapperH (F1 func1, F2 func2, std::tuple<Ts1...> const & tp1,
                 std::tuple<Ts2...> const & tp2,
                 std::index_sequence<Is1...> const &,
                 std::index_sequence<Is2...> const &)
 { return std::make_pair(std::bind(func1, std::get<Is1>(tp1)...),
                         std::bind(func2, std::get<Is2>(tp2)...)); }

template <typename F1, typename F2, typename ... Ts1, typename ... Ts2>
auto myWrapper (F1 func1, F2 func2, std::tuple<Ts1...> const & tp1,
                std::tuple<Ts2...> const & tp2)
 { return myWrapperH(func1, func2, tp1, tp2,
                     std::make_index_sequence<sizeof...(Ts1)>{},
                     std::make_index_sequence<sizeof...(Ts2)>{}); }

int foo (int a, int b)
 { return a+b; }

std::size_t bar (int a, int b, std::string const & str)
 { return str.size() + a + b; }

int main ()
 {
   auto mwr = myWrapper(&foo, &bar,
                 std::make_tuple(1, std::placeholders::_1),
                 std::make_tuple(110, 20, std::string{"something"}));

   std::cout << mwr.first(5) << std::endl; // print   6
   std::cout << mwr.second() << std::endl; // print 139
 }

Что касается вашего представления о variadicStruct, вы можете взглянуть на std::tuple.

template<class... Ts, class... Us>
void do_stuff(const std::tuple<Ts...>&, const std::tuple<Us...>&) {
  std::cout << "two variadic packs with " << sizeof...(Ts)
        << " and " << sizeof...(Us) << " elements." << std::endl;
}

Называется так:

do_stuff(std::make_tuple(4.7, 'x', 1.0, 4, 8l), std::make_tuple("foo", 1));

Вы можете использовать std::make_tuple и std::apply, например:

template <typename R, typename Func1, typename Args1>
void wrapper (Func1 f1, Args1 a1)
{
    std::function<R> wrapped1 = [f1, a1]{ return std::apply(f1, a1); };
}

// ...

auto deg_to_rad = [](int x){ return x / 180.f * 3.1415f; };
wrapper<float>(deg_to_rad, std::make_tuple(45));

std::apply требуется поддержка C++17. Однако связанная страница cppreference содержит возможную реализацию, которая работает на C+. +11.