使用元编程递归初始化 std::array

Question

我必须使用自定义分配器初始化 std::array<my_vector, N>、my_vector 和 std::vector。我的做法是：

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

简化后的代码如下所示：

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