如何实现函数模板推导std::initializer_list的嵌套层数？

首先，你遇到的问题核心是模板参数N和传入的List类型之间没有推导关联——编译器没法从std::initializer_list的嵌套结构自动推断出层数N。我们可以通过**类型特征（type traits）**来提取嵌套层数，让编译器自动完成推导，同时也可以针对你的场景推荐更合适的容器替代方案。

1. 改进函数模板：自动推导嵌套层数N #

第一步：实现嵌套层数的类型特征 #

先写一个递归的类型特征结构体，用来计算嵌套容器的深度：

#include <array>
#include <initializer_list>
#include <type_traits>

// 基础情况：非容器类型，嵌套深度为0
template<typename T>
struct nested_container_depth {
    static constexpr size_t value = 0;
};

// 针对std::initializer_list的递归特化
template<typename T>
struct nested_container_depth<std::initializer_list<T>> {
    static constexpr size_t value = 1 + nested_container_depth<T>::value;
};

// 便捷变量模板，简化代码调用
template<typename T>
constexpr size_t nested_container_depth_v = nested_container_depth<T>::value;

第二步：修改函数模板自动推导N #

更新你的some_function，让它利用上面的类型特征自动推导N，不需要手动指定：

template<typename List, size_t N = nested_container_depth_v<List>>
std::array<size_t, N> some_function(const List& list) {
    std::array<size_t, N> arr{}; // 初始化数组为0

    // 示例逻辑：填充每层的元素个数（你可以根据需求自定义）
    size_t current_idx = 0;
    // C++20模板lambda实现递归遍历
    auto traverse = [&]<typename U>(const U& current) {
        if constexpr (std::is_same_v<U, std::initializer_list<typename U::value_type>>) {
            arr[current_idx++] = current.size();
            for (const auto& elem : current) {
                traverse(elem);
            }
        }
    };

    traverse(list);
    return arr;
}

现在你的main函数可以直接调用，完全不需要手动指定N：

int main() {
    using List = std::initializer_list<std::initializer_list<double>>;
    List list = {{1.,2.,3.},{4.,5.,6.}};
    auto arr = some_function(list); // 自动推导arr为std::array<size_t, 2>
    // 此时arr的值为{2, 3}（第一层2个元素，每个第二层子列表有3个元素）
    return 0;
}

2. 替代方案：比std::initializer_list更合适的容器选择 #

std::initializer_list的设计初衷是快速初始化容器，它有不少局限性：生命周期绑定临时对象、无法修改元素、不支持动态扩容。如果你的场景需要更灵活的操作，以下两种方案更合适：

嵌套std::vector #

最常用的动态嵌套容器，支持修改元素、动态扩容、随机访问，且同样可以用初始化列表快速初始化：

#include <vector>

int main() {
    std::vector<std::vector<double>> vec = {{1.,2.,3.},{4.,5.,6.}};
    auto arr = some_function(vec); 
    return 0;
}

只需给nested_container_depth增加对std::vector的特化即可支持：

template<typename T, typename Alloc>
struct nested_container_depth<std::vector<T, Alloc>> {
    static constexpr size_t value = 1 + nested_container_depth<T>::value;
};

嵌套std::array #

如果嵌套层数和每层的元素个数都是编译期已知的，嵌套std::array是更高效的选择（栈内存分配，无动态内存开销）：

#include <array>

int main() {
    std::array<std::array<double, 3>, 2> arr = {{{1.,2.,3.},{4.,5.,6.}}};
    auto depth_arr = some_function(arr); // 自动推导深度为2
    return 0;
}

同样只需给nested_container_depth增加std::array的特化：

template<typename T, size_t Size>
struct nested_container_depth<std::array<T, Size>> {
    static constexpr size_t value = 1 + nested_container_depth<T>::value;
};

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