Question

TLTR ：我想根据存储在可变参数模板列表中的索引定义的特定顺序，将模板容器中的某些数组映射到函数的参数（我想不到一种更简单的方法来定义问题）。

使用void*存储数组，但在数组之间键入安全性，函数参数由辅助类保证。同一个帮助器类必须扩展给定的参数包，获取适当的数组，将它们绑定到函数指针并调用该函数。这就是我被困住的地方。

详细信息：我提前为冗长的问题道歉，并发布了无法编译的代码，但我尽量简明扼要。

问题在于将容器的正确成员映射到仿函数对象。容器有一个由typelist定义的数组列表，其实现类似于this one。

为简单起见，我们假设定义了类型列表帮助程序对象TLAlg::length<TL>和TLAlg::TypeAt，并允许用户分别访问类型列表和第N类型的长度。

容器类为类型列表中的每个类型（称为字段）分配一个数组，并存储一个指向这些缓冲区的不透明指针。实现类型安全的getter以访问特定的字段索引。其实施如下：

// container class, stores an array for each type in the typelist
template<class TL>
class Volume {
public:
    // list of opaque buffers
    void *opaque_buffers[TLAlg::length<TL>::value];

    template<int size>
    Volume(const size_t (&dim)[size]){
        // each opaque_buffers is initialized here
        ...
    }

    // getters are using the field index for type-safety
    template <int index> typename
    TLAlg::TypeAt<TL, index>::Result &
    get(const std::initializer_list<size_t> &position);
};

我们希望实现一个Functor对象，该对象将使用类型列表的特定子集在卷上应用给定函数。用户不是直接操作数组，而是给出他想要访问的字段的索引列表以及要应用的函数的指针。仿函数对象负责设置正确的参数。

为了提高类型安全性，我们将两个列表分开：只读和读/写（读const而不是const）。给定的函数原型必须与仿函数对象的定义一致：代码仅在给定的函数指针与参数定义完全匹配时才编译，因此我们不必担心类型不匹配。仿函数的实现是：

template<typename TL, class T1, class T2> struct Functor{};
template< typename TL,
          template<size_t...> class T1, size_t... A1, // read only arguments
          template<size_t...> class T2, size_t... A2  // read-write arguments
        >
struct Functor< TL, T1<A1...>, T2<A2...> >{
    // type of the function pointer
    typedef void (*Type)(const typename TLAlg::TypeAt<TL, A1>::Result* ... ,
                               typename TLAlg::TypeAt<TL, A2>::Result* ...);

    Functor(Volume<TL> &v, Type f): f(f){
        // At this point we have everything we need: the volume, the function
        // and the list of arguments, but how to combine them all?

        // maybe some magic here to map the opaque pointers to the arguments?
    }

    void operator()(){
        // or maybe here?
    }
}

正如您所看到的，仿函数目前没有做任何事情，因为我不知道如何将两个参数包映射到容器数组并将它们绑定到函数指针...

为清楚起见，以下是仿函数类的用法示例：

// main Typelist
typedef Typelist<float, Typelist<double, Typelist<int, NullType>>> Pixel;

// function we want to apply: reads first and last field of the list and updates second
void foo(const float  *f1, 
         const int    *f3,
               double *f2){}

// helper class to store the parameter packs
template<size_t ... T> struct Pack {};

int main(){
    // volume declaration
    Volume<Pixel> volume((size[]){1024,1024});

    // delare typesafe functor
    Functor<Pixel,     // typelist
            Pack<0,2>, // list of read-only fields
            Pack<1>    // list of read-write fields
           > apply_foo(volume, foo);

    apply_foo(); // <- this does nothing at the moment
}

我尝试使用std::forward和std::bind很长一段时间，但我还是找不到合适的解决方案。可以考虑替换std::tuple的类型列表，但最好保留当前的定义。

这段代码可能看起来很奇怪而且不必要地复杂，但它是一个非常简化的大型框架版本，使用这些类是有意义的。

任何帮助都将受到高度赞赏。

对Yakk答案的澄清：

我确实需要一个类型列表，因为我在其中做了更多魔术，例如列表中的每个元素都可以是元组而不是单个类型来关联名称。这允许整齐的代码，如：

typedef MakeTypeList((float,  p),
                     (float,  bnd),
                     (float,  gosa)) HimenoFields;

// I can now use aliases, and the declaration order does not matter in the code.
// here is an access to the second field:
volume.get<HimenoFields::bnd>({0,0,0});

你可以想象这是如何与我想用仿函数实现的操作完美结合的。

其次，我理解为什么你被吸气剂弄糊涂了。正如我最初所说，这是一个非常简化的代码版本，尽管问题很长。在真实程序中，体积是多维的，要么在单个阵列中展平，要么在多维数组中分配，这就是吸气剂需要完整坐标的原因。这些具有不同参数的getter有几种实现方式。

最后，Functor不需要知道应用函数的元素，因为它本身控制迭代空间并应用预定义的骨架（即模板，波前......）。为了简单起见，我再次省略了它。

Answer 1

首先，我会重写你的type_list：

template<typename... Ts>
struct type_list {};

使用variardic类型而不是你的18个参数hack。写type_at<n>::type和index_of<T>::value然后很难。这些与基于配对的TypeList之间的映射也不难。

template<typename list>
struct make_TypeList;

template<typename T0, typename T1, typename...Ts>
struct make_TypeList<type_list<T0, T1, Ts...>> {
  typedef typename make_Typelist< type_list<T1, Ts...> >::type tail;
  typedef TypeList< T0, tail > type;
};
template<typename T0>
struct make_TypeList<type_list<T0>> {
  typedef TypeList< T0, NullType > type;
};
template<>
struct make_TypeList<type_list<>> {
  typedef NullType type;
};

如果你真的需要它。有理由使用非类型列表，但您没有证明任何类型。

构建编译时类型索引的集合有点棘手，但如果传入上限，则可以执行此操作。目标是创建一个序列：

template<size_t... s>
struct seq {};

如果要在编译时获取这些索引，这会更容易。一旦你有了这个序列，并且你有type_at，你可以写一个这样的调用函数：

template<size_t... s, typename... Ts>
void evaluate( seq<s...> unused, void(*func)(Ts*... ts) ) {
  func( &get_at<s>()... );
}

我们将序列直接解压缩到函数调用中。碰巧的是，有问题的序列通常只是0,1,2,3,4,...,n-1，可以很容易地生成：

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

要明确：operator()在执行make_seq<sizeof...(Ts)>::type()之后调用辅助函数，将其传递给辅助函数，然后调用func( &get_at<s>(/*n maybe?*/)... )，而bob是你的叔叔

令我困惑的一件事是：

// getters are using the field index for type-safety
template <int index> typename
TLAlg::TypeAt<TL, index>::Result &
get(const std::initializer_list<size_t> &position);

我不确定为什么需要const std::initializer_list<size_t> &position，或者至少为什么你没有：

template <int index> typename
TLAlg::TypeAt<TL, index>::Result &
get_at(size_t n);

这让我觉得您的仿函数中的operator()缺失了＃34;如果您的Volume是多个类型的数组，我会将这个仿函数应用到＆＃34;。< / p>

但是我强烈怀疑＆＃34;制作一组索引，调用辅助函数以便你可以获得内容，然后在函数调用中扩展包＃34;是你缺少的技巧。

使用可变参数模板和类型列表将不透明数组映射到函数参数

1 个答案: