異構序列生成器

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