如何初始化嵌套std::array？模板化场景的初始化方案咨询

很高兴帮你解决嵌套std::array的初始化问题！针对你提到的手写重复初始化列表麻烦、模板场景下无法预先确定大小的痛点，这里有几种实用的初始化方案——都是真正的初始化操作，而非构造后赋值：

1. 固定大小场景：复用子数组变量（C++11+） #

如果数组大小是固定的，不用反复写重复的{1,2,3}，先定义一个子数组常量，再在初始化列表里重复用它就行：

#include <array>

int main() {
    constexpr std::array<int, 3> sub_arr = {1, 2, 3};
    std::array<std::array<int, 3>, 3> x{sub_arr, sub_arr, sub_arr};
    // 所有子数组都被初始化为{1,2,3}
}

这种写法既简洁，又完全是初始化阶段完成的，符合你的要求。

2. 模板场景：编译期生成填充数组（C++17+） #

对于模板参数不确定大小的情况，我们可以写一个constexpr辅助函数，在编译期直接生成填充好的嵌套数组，然后在构造函数的初始化列表里调用它：

#include <array>

template <size_t T, size_t n, int N>
constexpr std::array<std::array<int, n>, T> create_filled_nested_array() {
    std::array<std::array<int, n>, T> arr{};
    // C++17开始允许constexpr函数里用循环
    for (auto& sub_arr : arr) {
        sub_arr.fill(N);
    }
    return arr;
}

template <size_t n, size_t T>
struct foo {
    std::array<std::array<int, n>, T> x;
    
    // 直接在初始化列表里完成x的初始化
    constexpr foo() : x(create_filled_nested_array<T, n, 42>()) {}
    
    // 如果需要外部传入N，改成带参数的构造函数即可：
    // constexpr foo(static constexpr int N) : x(create_filled_nested_array<T, n, N>()) {}
};

这个方案的好处很明显：

• 完全在编译期完成初始化（只要N是constexpr），没有运行期开销
• 不管n和T是多大，都不用手写重复的初始化列表
• 属于构造阶段的初始化，不是构造后的赋值操作

3. 兼容C++14的方案：用索引序列展开 #

如果你的项目需要兼容C++14（不支持constexpr循环），可以借助std::index_sequence来展开子数组的初始化：

#include <array>
#include <utility> // 用于std::index_sequence

template <size_t n, int N>
constexpr std::array<int, n> make_filled_subarray() {
    std::array<int, n> sub{};
    // 用索引序列展开填充每个元素
    auto fill_sub = [&]<size_t... Is>(std::index_sequence<Is...>) {
        (void)(sub[Is] = N, ...); // 折叠表达式完成批量赋值
    };
    fill_sub(std::make_index_sequence<n>{});
    return sub;
}

template <size_t T, size_t n, int N, size_t... Is>
constexpr std::array<std::array<int, n>, T> create_filled_impl(std::index_sequence<Is...>) {
    // 展开T次，每次生成一个填充好的子数组
    return {{ (Is, make_filled_subarray<n, N>())... }};
}

template <size_t T, size_t n, int N>
constexpr std::array<std::array<int, n>, T> create_filled_nested_array() {
    return create_filled_impl<T, n, N>(std::make_index_sequence<T>{});
}

// 结构体的用法和之前一致
template <size_t n, size_t T>
struct foo {
    std::array<std::array<int, n>, T> x;
    constexpr foo() : x(create_filled_nested_array<T, n, 42>()) {}
};

4. C++20更简洁的写法：模板lambda+参数推导 #

C++20的模板lambda和自动参数推导能让代码更紧凑，省去不少模板参数的书写：

#include <array>
#include <utility>

template <size_t T, size_t n, int N>
constexpr auto create_filled_nested_array() {
    // 先定义生成单个填充子数组的lambda
    auto make_sub = []() constexpr {
        std::array<int, n> sub{};
        sub.fill(N);
        return sub;
    };
    // 用索引序列展开生成T个子数组
    return [&]<size_t... Is>(std::index_sequence<Is...>) {
        return std::array<std::array<int, n>, T>{ (Is, make_sub())... };
    }(std::make_index_sequence<T>{});
}

最后补充 #

所有这些方案都是在对象构造阶段完成初始化，完全符合你不想用循环赋值的需求；如果N是static constexpr，整个初始化过程还能在编译期完成，不会有任何运行期的额外开销。

内容的提问来源于stack exchange，提问作者enanone