Question

这是我想要实现的目标：

一个模板类，它有N个变量成员，每个成员可能有不同的类型。此类也可以在外部获得N个函数/仿函数，以便每个仿函数将使用相应的类型更新成员变量。理想情况下，我希望N是未知的，这意味着我们需要Variadic模板。

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

template<typename T1, typename T2>
class TwoInput
{
public:
    TwoInput(T1 (*f1)(), T2 (*f2)()) : _f1(f1), _f2(f2) {};
    void run(){
    t1 = (*_f1)();
    t2 = (*_f2)();
    };
    void output(){std::cout<<_t1<<std::endl; std::cout<<_t2<<std::endl;};
protected:
    T1 _t1;
    T2 _t2;
    T1 (*_f1)();
    T2 (*_f2)();
};

Answer 1

从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 );
}

或类似的东西（未经测试，我需要去睡觉）。

如何使用N种不同类型的变量成员创建模板类

1 个答案: