如何获取容器模板类型以复用其结构适配新value_type？

这个问题问得很好——确实，模板模板参数在面对不同模板参数数量的容器时会束手无策，不过我们可以通过类型萃取（type traits）+ 部分特化的方式来实现你想要的效果：从传入的容器类型中“提取”出它的模板，并替换掉元素类型，同时保留原容器的其他模板参数（比如分配器、比较器等）。

1. 定义通用的类型萃取模板 #

首先我们先声明一个基础的萃取模板，后续针对不同容器做特化：

#include <vector>
#include <list>
#include <set>
#include <map>
#include <algorithm>
#include <iterator>

// 基础声明：用于替换容器的元素类型
template<typename Container>
struct container_value_replaced;

2. 针对标准容器特化萃取模板 #

接下来，为常用的标准容器编写特化版本，指定如何替换元素类型，同时保留其他模板参数：

// 特化std::vector：替换第一个模板参数（元素类型），保留分配器
template<typename T, typename Alloc>
struct container_value_replaced<std::vector<T, Alloc>> {
    template<typename NewValue>
    using type = std::vector<NewValue, Alloc>;
};

// 特化std::list：同理保留分配器
template<typename T, typename Alloc>
struct container_value_replaced<std::list<T, Alloc>> {
    template<typename NewValue>
    using type = std::list<NewValue, Alloc>;
};

// 特化std::set：替换键类型（set的value_type就是键），保留比较器和分配器
template<typename Key, typename Compare, typename Alloc>
struct container_value_replaced<std::set<Key, Compare, Alloc>> {
    template<typename NewKey>
    using type = std::set<NewKey, Compare, Alloc>;
};

// 特化std::map：替换值类型（map的value_type是std::pair<const Key, T>，这里替换T）
template<typename Key, typename T, typename Compare, typename Alloc>
struct container_value_replaced<std::map<Key, T, Compare, Alloc>> {
    template<typename NewValue>
    using type = std::map<Key, NewValue, Compare, Alloc>;
};

3. 修改你的转换函数模板 #

现在，把原来硬编码的std::vector<OutputType>替换为萃取后的容器类型，同时保留原有的OutputType推导逻辑：

// 假设你有一个处理单个元素的convert函数（示例）
int convert(double val) {
    return static_cast<int>(val);
}

// 转换容器的函数模板
template<typename ContainerType, typename OutputType = decltype(convert(std::declval<typename ContainerType::value_type>()))>
typename container_value_replaced<ContainerType>::template type<OutputType> convert(const ContainerType& input) {
    using ResultContainer = typename container_value_replaced<ContainerType>::template type<OutputType>;
    ResultContainer result;

    // 用constexpr if判断容器是否支持reserve，避免对list等容器调用该方法
    if constexpr (requires { input.size(); result.reserve(input.size()); }) {
        result.reserve(input.size());
    }

    std::transform(input.begin(), input.end(), std::back_inserter(result), 
                   static_cast<OutputType(*)(typename ContainerType::value_type)>(&convert));
    return result;
}

4. 测试示例 #

你可以这样验证这个函数的效果：

#include <iostream>

int main() {
    std::vector<double> vec = {1.1, 2.2, 3.3};
    auto int_vec = convert(vec); // 得到std::vector<int>

    std::list<double> lst = {4.4, 5.5, 6.6};
    auto int_lst = convert(lst); // 得到std::list<int>

    std::map<int, double> mp = {{1, 7.7}, {2, 8.8}};
    auto int_mp = convert(mp); // 得到std::map<int, int>

    // 输出验证
    for (int val : int_vec) std::cout << val << " "; // 1 2 3
    std::cout << "\n";
    for (int val : int_lst) std::cout << val << " "; // 4 5 6
    std::cout << "\n";
    for (auto& pair : int_mp) std::cout << pair.first << ":" << pair.second << " "; // 1:7 2:8
}

关键细节说明 #

• 为什么不用模板模板参数？ 正如你所说，不同容器的模板参数数量差异很大：std::vector有2个，std::set有3个，std::map有4个。模板模板参数需要提前固定参数数量，无法兼容所有容器类型；而类型萃取+部分特化可以针对每个容器单独处理，灵活性更高。
• 扩展支持其他容器：如果需要支持自定义容器或其他标准容器（比如std::deque、std::unordered_map），只需要给container_value_replaced添加对应的特化版本即可。
• constexpr if优化：代码中用if constexpr判断容器是否支持reserve方法，避免对不支持该方法的容器（比如list）调用导致编译错误。

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