如何在C++17中编写支持泛型嵌套容器与原生花括号表达式的函数？

嗨，我完全懂你的痛点：要兼容各种嵌套容器（带自定义分配器的std::vector、std::list都得支持），还要适配花括号初始化，参数多了重载直接爆炸——3个参数就要写8个重载，确实太不优雅了。下面分别给你讲C17的简洁解决方案，以及C20用Concept的完美实现。

C++17：去掉默认参数，用通用模板自动推导 #

你之前的问题其实出在模板参数的默认值上：当你给模板加了typename LLO = std::vector<std::vector<int>>这个默认参数后，编译器会优先尝试推导模板参数，但花括号初始化列表（braced-init-list）没有明确类型，导致推导失败，所以你不得不加重载。

解决方法超简单：去掉模板参数的默认值，写一个完全通用的模板函数，让编译器自动推导传入的类型——包括std::initializer_list（它本身支持遍历，和容器一样能用范围for循环）。

代码示例：

#include <iostream>
#include <list>
#include <vector>

// 完全通用的模板，支持任何可遍历的嵌套类型
template <typename OuterContainer>
void f(const OuterContainer& outer) {
    for (const auto& inner : outer) {
        for (const auto& elem : inner) {
            std::cout << elem;
        }
        std::cout << '\n';
    }
}

int main() {
    // 所有测试用例都能直接通过
    f({{1, 2}, {3, 4}});                  // 推导为 initializer_list<initializer_list<int>>
    f({std::vector{1, 2}, {3, 4}});       // 推导为 initializer_list<vector<int>>
    f(std::list{std::list{1, 2}, {3, 4}});// 推导为 list<list<int>>
    f({std::list{1, 2}, {3, 4}});         // 推导为 initializer_list<list<int>>
    
    // 带自定义分配器的vector也完美支持
    using CustomAlloc = std::allocator<int>;
    f(std::vector<std::vector<int, CustomAlloc>, CustomAlloc>{
        std::vector<int, CustomAlloc>{1,2},
        std::vector<int, CustomAlloc>{3,4}
    });
}

这个方案不需要任何重载，哪怕你有3个嵌套容器参数，改成变参模板就行：

template <typename... Containers>
void f(const Containers&... containers) {
    // 用折叠表达式批量处理每个参数
    (process_container(containers), ...);
}

如果想严格限制参数必须是“容器套容器”（而非任意可遍历类型），可以用SFINAE加容器检测trait：

#include <type_traits>

// 检测是否是可遍历类型（容器或initializer_list）
template <typename T, typename = void>
struct is_range : std::false_type {};

template <typename T>
struct is_range<T, std::void_t<decltype(std::begin(std::declval<T>())),
                               decltype(std::end(std::declval<T>()))>>
    : std::true_type {};

template <typename T>
constexpr bool is_range_v = is_range<T>::value;

// 约束：外层是range，内层也是range
template <typename OuterCont>
std::enable_if_t<is_range_v<OuterCont> && is_range_v<typename OuterCont::value_type>>
void f(const OuterCont& outer) {
    // 函数体同上
}

C++20：用Concept优雅约束类型 #

C++20的Concept可以直接把“嵌套容器”的要求写在函数参数上，代码可读性拉满，而且完全不需要重载：

#include <concepts>
#include <iostream>
#include <list>
#include <vector>

// 定义Concept：嵌套的可遍历范围，且最内层元素是int
template <typename T>
concept NestedIntContainer = requires(T t) {
    requires std::ranges::range<T>; // 外层是可遍历范围
    requires std::ranges::range<std::ranges::range_value_t<T>>; // 内层也是可遍历范围
    requires std::same_as<std::ranges::range_value_t<std::ranges::range_value_t<T>>, int>; // 最内层是int
};

// 直接用Concept约束参数
void f(NestedIntContainer auto const& outer) {
    for (auto const& inner : outer) {
        for (int elem : inner) {
            std::cout << elem;
        }
        std::cout << '\n';
    }
}

int main() {
    // 所有测试用例依然完美支持
    f({{1, 2}, {3, 4}});
    f({std::vector{1, 2}, {3, 4}});
    f(std::list{std::list{1, 2}, {3, 4}});
    f({std::list{1, 2}, {3, 4}});
    
    // 自定义分配器的容器也没问题
    using CustomAlloc = std::allocator<int>;
    f(std::vector<std::vector<int, CustomAlloc>, CustomAlloc>{
        std::vector<int, CustomAlloc>{1,2},
        std::vector<int, CustomAlloc>{3,4}
    });
}

这个Concept清晰地表达了函数参数的要求：必须是嵌套的可遍历范围，且最内层元素是int。如果传入不符合要求的类型，编译器会给出非常友好的错误提示，比SFINAE的晦涩错误信息好懂太多。

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