异构序列生成器

Heterogeneous sequence generator

本文关键字：异构      更新时间：2023-10-16

在本主题Variadic模板异构容器的延续中，我想问以下问题。假设我们有几个类，其中有两个成员，它们是动态数组。现在假设有一系列这些类的对象，它们被封装在异构容器中。在这个序列中，数组成员之一是"输出"向量，另一个数组成员是"输入"向量，它是指向前面对象的适当输出数组的指针。该序列被实现为可变模板类：

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

如何为输出向量正确分配内存（通过new/malloc），并设置指向前面输出向量的输入指针？例如，我写下一个代码：

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

我希望序列的第一个成员的输入是nullptr，从第二个到第一个的input。如何正确实现它？

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

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

受Useless答案的启发（并非双关语），我想出了这个：

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();
    }
};
相关文章：