异构序列生成器

Question

在继续这个主题Variadic template heterogeneous container，我想问以下问题。假设我们有两个动态数组成员的类。现在假设有这些类的一系列对象，这些对象被封装在异构容器中。在这个序列中，一个数组 - mebers是“输出”向量，另一个数组成员是“输入”向量，它是指向前一个对象的适当输出数组的指针。为输出矢量

//Classes, objects which are members of the sequence 
template<int NumberElements> 
struct A 
{ 
    A() : output(new float[NumberElements]){}//allocate output 
    ~A(){delete[] output;} 
    float *input;//input vector - pointer to output vector from preceding object of sequence 
    float *output;// output vector (size - NumberElements) of current member of sequence 
}; 
template<int NumberElements> 
struct B 
{ 
    B() : output(new float[NumberElements]){}//allocate output 
    ~B(){delete[] output;} 
    float *input; 
    float *output; 
}; 
template<int NumberElements>  
struct C 
{ 
    C() : output(new float[NumberElements]){}//allocate output 
    ~C(){delete[] output;} 
    float *input; 
    float *output; 
}; 

//Container 
template<typename...Arg> 
struct HeterogenousContainer 
{ 
    HeterogenousContainer();//Do something to setup the sequence 
    std::tuple<Arg...> elements; 

}; 

我怎样才能正确地分配存储器（经由新/ malloc的），并设置输入指针输出向量前述：该序列被实现为可变参数模板类？例如，我写下一个代码：

HeterogenousContainer<A<5>, B<7>, C<9>> sequence; 

我想要输入从序列的第一成员为nullptr，输入从第二 - 第一自等点输出如何正确实施？

Answer 1

通过Useless'answer启发（没有双关语意），我想出了这个：

template<typename...Arg> 
struct HeterogenousContainer 
{ 
    std::tuple<Arg...> elements; 

    void init(std::integral_constant<std::size_t, 0>) 
    { 
     std::get<0>(elements).input = nullptr; 
    } 

    template < std::size_t index = sizeof...(Arg)-1 > 
    void init(std::integral_constant<std::size_t, index> = {}) 
    { 
     std::get<index>(elements).input = std::get<index-1>(elements).output; 
     init(std::integral_constant<std::size_t, index-1>{}); 
    } 

    HeterogenousContainer() 
     : elements{} 
    { 
     init(); 
    } 
}; 

Answer 2

首先，如果可以避免的话，不要乱用手动（分配）分配。对于一个简单的数组，您可以：

#include <array> 
#include <tuple> 

template<int NumberElements> 
struct A 
{ 
    float *input; 
    std::array<float, NumberElements> output; 
}; 

您只需要对元组进行递归，并专门针对终止情况。因为第一个元素是你的特殊情况，所以我做了倒退。

namespace detail { 
    template <int N> struct Connector; 

    template <> 
    struct Connector<0> { 
     template <typename... TL> static void connect(std::tuple<TL...> &t) { 
      std::get<0>(t).input = nullptr; 
     } 
    }; 

    template <int N> struct Connector { 
     template <typename... TL> static void connect(std::tuple<TL...> &t) { 
      std::get<N>(t).input = &std::get<N-1>(t).output.front(); 
      Connector<N-1>::connect(t); 
     } 
    }; 

    template <typename... TL> void connect(std::tuple<TL...> &t) { 
     Connector<sizeof...(TL)-1>::connect(t); 
    } 
} 

，并使用它是这样的：

template <typename... Arg> struct HeterogenousContainer { 
    std::tuple<Arg...> elements; 

    HeterogenousContainer() { detail::connect(elements); } 
};