时间戳

首页 > 解决方案 > 使用元编程递归初始化 std::array

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

问题描述

我必须使用自定义分配器初始化 a std::array<my_vector, N>，my_vector作为 a 。std::vector我这样做的方式是：

  1. 分配的N内存池
  2. 创建了一个std::arrayof allocator，每个都有自己的内存池
  3. 创建了一个std::arrayof 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 只支持聚合初始化。

标签： c++templatesmetaprogrammingtemplate-meta-programming

解决方案

你不需要任何递归来实现这一点，你可以简单地使用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>{});
}

godbolt.org 上的实时示例

推荐阅读