C++ 如何使用N种不同类型的变量成员创建模板类，以便

以下是我想要实现的目标：

一个模板类，它有N个变量成员，每个成员可能有不同的类型。此外，该类还可以从外部获取N个函数/函子，以便每个函子将更新具有相应类型的成员变量。理想情况下，我想N是未知的，这意味着我们需要可变模板

这是一个N=2的例子（我理想情况下希望它是函子，而不是函数，但在这方面我也有一些困难。）

模板
第二类输入
{
公众：
两个输入（T1（*f1）（），T2（*f2）（）：_f1（f1），_f2（f2）{}；
无效运行（）{
t1=（*_f1）（）；
t2=（*f2）（）；
};
void output（）{std:：cout从数据的
std:：tuple
开始

然后变异类型以创建函数的
std:：tuple

然后编写一个函数，将函数的
std:：tuple
应用于数据的
std:：tuple

#include <utility>

template< template<typename>class Typemap, typename Tuple>
struct map_types;
template< template<typename>class Typemap, template<typename...>class pack, typename... Args>
struct map_types< Typemap, pack<Args...> > {
  typedef pack< Typemap<Args>... > type;
};

template< template<typename>class Typemap, typename Tuple>
using MapTypes = typename map_types<Typemap, Tuple>::type;

template< typename T >
using NullaryFuncReturning = T(*)();

template<int...> struct seq {};
template<int max, int... s> struct make_seq:make_seq<max-1, max-1, s...> {}:
template<int... s> struct make_seq<0,s...>:seq<s...> {};

void do_in_order() {}
template<typename F0, typename... Fs>
void do_in_order( F0&& f0, Fs&&... fs ) {
  std::forward<F0>(f0)();
  do_in_order( std::forward<Fs>(fs)... );
}

template< int... s, typename Funcs, typename Data >
void pairwise_apply_helper( seq<s...>, Funcs&& funcs, Data&& data ) {
  do_in_order( [&]{ std::get<s>(data) = std::get<s>( funcs )() }... );
}
template< typename... Funcs, typename... Data >
void pairwise_apply( std::tuple<Funcs...> funcs, std::tuple<Data...>& data ) {
  pairwise_apply_helper( make_seq<sizeof...(Funcs)>, std::move(funcs), data );
}

typedef std::tuple<int, double, int> data_type;
MapTypes< NullaryFuncReturning, data_type > func_type;

int seven() { return 7; }
double approx_pi() { return 3.14; }

data_type data;
func_type func{seven, approx_pi, seven};
#include <iostream>
int main() {
  pairwise_apply( func, data );
}

#包括
模板
结构映射类型；
模板
结构映射类型{
typedef包类型；
};
模板
使用MapTypes=typename map\u types:：type；
模板
使用NullaryFuncReturning=T（*）（）；
模板结构seq{}；
模板结构make_seq:make_seq{}：
模板结构make_seq:seq{}；
void do_in_order（）{}
模板
按顺序作废do_（F0&&F0，Fs&&Fs）{
std:：forward（f0）（）；
按顺序进行（标准：转发（fs）…）；
}
模板
无效成对应用辅助对象（顺序、函数和函数、数据和数据）{
按顺序执行（[&]{std:：get（data）=std:：get（funcs）（}；
}
模板
无效成对应用（标准：：元组函数、标准：：元组和数据）{
成对应用辅助对象（make_seq，std:：move（funcs），data）；
}
typedef std:：元组数据类型；
MapTypesfunc_type；
int seven（）{return 7；}
双近似π（）{return 3.14；}
数据类型数据；
func_型func{seven，约π，seven}；
#包括
int main（）{
成对应用（函数、数据）；
}

或者类似的东西（未经测试，我需要去睡觉）。
看看：：std：：tuple我已经考虑过了。它似乎不适合这里。基本上，这里我需要2N种不同的类型（一半用于变量，另一半用于函子）
#include <utility>

template< template<typename>class Typemap, typename Tuple>
struct map_types;
template< template<typename>class Typemap, template<typename...>class pack, typename... Args>
struct map_types< Typemap, pack<Args...> > {
  typedef pack< Typemap<Args>... > type;
};

template< template<typename>class Typemap, typename Tuple>
using MapTypes = typename map_types<Typemap, Tuple>::type;

template< typename T >
using NullaryFuncReturning = T(*)();

template<int...> struct seq {};
template<int max, int... s> struct make_seq:make_seq<max-1, max-1, s...> {}:
template<int... s> struct make_seq<0,s...>:seq<s...> {};

void do_in_order() {}
template<typename F0, typename... Fs>
void do_in_order( F0&& f0, Fs&&... fs ) {
  std::forward<F0>(f0)();
  do_in_order( std::forward<Fs>(fs)... );
}

template< int... s, typename Funcs, typename Data >
void pairwise_apply_helper( seq<s...>, Funcs&& funcs, Data&& data ) {
  do_in_order( [&]{ std::get<s>(data) = std::get<s>( funcs )() }... );
}
template< typename... Funcs, typename... Data >
void pairwise_apply( std::tuple<Funcs...> funcs, std::tuple<Data...>& data ) {
  pairwise_apply_helper( make_seq<sizeof...(Funcs)>, std::move(funcs), data );
}

typedef std::tuple<int, double, int> data_type;
MapTypes< NullaryFuncReturning, data_type > func_type;

int seven() { return 7; }
double approx_pi() { return 3.14; }

data_type data;
func_type func{seven, approx_pi, seven};
#include <iostream>
int main() {
  pairwise_apply( func, data );
}