使用元编程递归初始化std：：数组

Question

我必须初始化一个std::array<my_vector, N>，my_vector是一个带有自定义分配器的std::vector。我的做法是：

1. 分配的N内存池
2. 创建了一个std::array of allocator，每个人都有自己的内存池
3. 创建了一个std::array of std::vector，每个人都有自己的分配器。

简化的代码如下所示：

std::array<std::array<char, POOL_SIZE>, N> memory_pools;

std::array<allocator<POOL_SIZE>, N> allocators{
    std::get<0>(memory_pools),
    std::get<1>(memory_pools),
    std::get<2>(memory_pools),
    //...
    std::get<N-1>(memory_pools),
};

using my_vector = std::vector<my_class, my_allocator>;

std::array<my_vector, N> vectors{
    my_vector{std::get<0>(allocators)},
    my_vector{std::get<1>(allocators)},
    my_vector{std::get<2>(allocators)},
    //...
    my_vector{std::get<N-1>(allocators)},
}

但是，这是相当冗长的，因为我的常量N超过100，手工编写所有这些都会产生臃肿的代码，当我更改N时，我必须再次编写整个部分。

问:有没有办法让编译器为我写初始化？

我想做的是

std::array<allocator<POOL_SIZE>, N> allocators =
make_array_from_pool<POOL_SIZE, N>(memory_pools);

std::array<my_vector, N> vectors = 
make_array_from_allocators<N>(allocators);

我已经尝试在嵌套类中执行一些递归模板化函数，但是我遇到了转换错误。

这大概是我在尝试的：

template<size_t POOL_SIZE, size_t N, size_t ORDER> 
class ArrayMaker{
    static std::array<allocator<POOL_SIZE>, ORDER> from_pool(
    std::array<std::array<char, POOL_SIZE>, N>
    memory_pool
){
    return {
        ArrayMaker<POOL_SIZE, N, ORDER-1>::from_pool(memory_pool),
        std::get<ORDER-1>(memory_pool)
    };
}
};

template<size_t POOL_SIZE, size_t N> 
class ArrayMaker<POOL_SIZE, N, 1>{
    static std::array<allocator<POOL_SIZE>, 1> from_pool(
    std::array<std::array<char, POOL_SIZE>, N>
    memory_pool
){
    return {std::get<0>(memory_pool)};
}
};

template<size_t POOL_SIZE, size_t N> 
static std::array<allocator<POOL_SIZE>, N> make_array_from_pool(
    std::array<std::array<char, POOL_SIZE>, N>
    memory_pool
){
    return ArrayMaker<POOL_SIZE,N, N>::from_pool(memory_pool);
}

我得到的错误是could not convert ... from '<brace-enclosed initializer list>' to 'std::array<allocator<POOL_SIZE>, 2>'

我的理解是，这是因为std::array只支持聚合初始化。

Answer 1

您不需要任何递归来实现这一点，只需使用std::index_sequence即可。例如。

template <std::size_t... Is>
void init_arrays_impl(std::index_sequence<Is...>)
{
    static constexpr auto N = sizeof...(Is);

    std::array<std::array<char, POOL_SIZE>, N> memory_pools;

    std::array<allocator<POOL_SIZE>, N> allocators{
        std::get<Is>(memory_pools)...
    };

    using my_vector = std::vector<my_class, my_allocator>;

    std::array<my_vector, N> vectors{
        my_vector{std::get<Is>(allocators)}...
    };
}

template <std::size_t N>
void init_arrays()
{
    init_arrays_impl(std::make_index_sequence<N>{});
}

live example on godbolt.org