C++ 异构序列发生器

在继续这一主题时，我想问以下问题。假设我们有几个类，其中两个成员是动态数组。现在假设这些类有一系列对象，它们被打包在异构容器中。在这个序列中，一个数组meber是“输出”向量，另一个数组成员是“输入”向量，它是指向前一个对象的适当输出数组的指针。此序列作为可变模板类实现：

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

};

//类，是序列成员的对象
模板
结构A
{
A（）：输出（新浮点[numberrelations]）{}//分配输出
~A（）{delete[]输出；}
float*input；//输入向量-指向序列前面对象的输出向量的指针
float*output；//序列当前成员的输出向量（size-numberrelations）
};   
模板
结构B
{
B（）：输出（新浮点[numberrelations]）{}//分配输出
~B（）{delete[]输出；}
浮点*输入；
浮点*输出；
};
模板
结构C
{
C（）：输出（新浮点[numberrelations]）{}//分配输出
~C（）{delete[]输出；}
浮点*输入；
浮点*输出；
};
//容器
模板
结构异源容器
{
HeterogenousContainer（）；//做些什么来设置序列
std：：元组元素；
};

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

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

异源内含子序列；

---

我希望序列的第一个成员的输入是nullptr，第二个点的输入是第一个点的输出是，等等。如何正确地实现它？

首先，如果可以避免的话，不要乱搞手动（de）分配。对于简单阵列，您可以：

#include <array>
#include <tuple>

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

#包括
#包括
模板
结构A
{
浮点*输入；
std：：阵列输出；
};

您只需要递归元组，并专门处理终止情况。因为第一个元素是你的特例，所以我是倒着做的

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

名称空间详细信息{
模板结构连接器；
模板
结构连接器{
模板静态void connect（std:：tuple&t）{
std:：get（t）.input=nullptr；
}
};
模板结构连接器{
模板静态void connect（std:：tuple&t）{
std:：get（t）.input=&std:：get（t）.output.front（）；
连接器：：连接（t）；
}
};
模板void connect（std:：tuple&t）{
连接器：：连接（t）；
}
}

并使用类似这样的方式：

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

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

模板结构异源容器{
std：：元组元素；
异源容器（）{detail:：connect（elements）；}
};

首先，如果可以避免的话，不要乱搞手动（取消）分配。对于简单阵列，您可以：

#include <array>
#include <tuple>

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

#包括
#包括
模板
结构A
{
浮点*输入；
std：：阵列输出；
};

您只需要递归元组，并专门处理终止情况。因为第一个元素是你的特例，所以我是倒着做的

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

名称空间详细信息{
模板结构连接器；
模板
结构连接器{
模板静态void connect（std:：tuple&t）{
std:：get（t）.input=nullptr；
}
};
模板结构连接器{
模板静态void connect（std:：tuple&t）{
std:：get（t）.input=&std:：get（t）.output.front（）；
连接器：：连接（t）；
}
};
模板void connect（std:：tuple&t）{
连接器：：连接（t）；
}
}

并使用类似这样的方式：

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

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

模板结构异源容器{
std：：元组元素；
异源容器（）{detail:：connect（elements）；}
};

灵感来源于（并非双关语），我提出了以下建议：

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

模板
结构异源容器
{
std：：元组元素；
void init（标准：：积分常数）
{
std:：get（elements）.input=nullptr；
}
模板
void init（std:：integral_常量={}）
{
std:：get（元素）。输入=std:：get（元素）。输出；
init（std：：积分常数{}）；
}
异源内含物（）
：元素{}
{
init（）；
}
};

灵感来源于（并非双关语），我提出了以下建议：

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

模板
结构异源容器
{
std：：元组元素；
void init（标准：：积分常数）
{
std:：get（elements）.input=nullptr；
}
模板
void init（std:：integral_常量={}）
{
std:：get（元素）。输入=std:：get（元素）。输出；
init（std：：积分常数{}）；
}
异源内含物（）
：元素{}
{
init（）；
}
};

为什么要在一个能够提供对其元素的各种（包括随机）访问的容器内构建一个链表？假设对元素的访问顺序是从a到C（在上面的示例中），那么为什么要在一个能够提供各种访问的容器内构建一个链表呢（包括随机）对其元素的访问？假设对元素的访问将是顺序的-在上面的示例中，从A到C强烈排列std:：array是否可以按16字节对齐以供SSE intrinsics使用？不是直接对齐。或者将您的

std:：array

包装在处理对齐的东西中（或者使用特定于编译器的属性-您还没有说您正在使用哪个编译器），或者切换到

std:：unique_ptr

和合适的分配器。这实际上是一个单独的问题。是否可以将std:：array按16字节对齐以供SSE intrinsics使用？不直接。或者将

std:：array

包装在处理对齐的东西中（或者使用编译器特定的属性）