如何约束嵌套std::map的键与值的最内层类型？

问题描述 #

已基于C++20 Concepts实现嵌套std::vector的最内层类型约束，代码如下：

// trait to get the innermost type
template <typename T>
struct inner_type
{
    using type = T;
};

// vector specialization
template <typename T>
struct inner_type<std::vector<T>>
{
    using type = typename inner_type<T>::type;
};

// alias for convenience
template<typename T>
using inner_type_t = typename inner_type<T>::type;

template<typename T>
concept IsInnerTypeInt = (std::same_as<inner_type_t<T>, int>);

template<typename Arg>
requires IsInnerTypeInt<Arg>
auto bar(Arg arg)
{

}

int main() {
    std::vector<int> intvec{1, 2, 3};
    std::vector<std::vector<int>> intvec_vec{{1,2}, {3, 4}};

    bar(intvec);
    bar(intvec_vec);
}

但尝试为嵌套std::map添加特化以同时约束键和值的最内层类型时，编写以下代码会触发重定义错误：

// map value specialization
template<typename Key, typename Val>
struct inner_type<std::map<Key, Val>>
{
    using type = typename inner_type<Val>::type;
};

// map key specialization
template<typename Key, typename Value>
struct inner_type<std::map<Key, Value>>
{
    using type = typename inner_type<Key>::type;
};

原因是同一个std::map<Key, Val>类型只能对应一个inner_type模板特化，无法通过两次特化分别提取键和值的内层类型。

解决方案 #

需要拆分trait，分别定义用于提取键的最内层类型和值的最内层类型的独立模板，再通过Concept组合约束条件。

完整实现代码 #

#include <vector>
#include <map>
#include <concepts>

// 基础trait：提取任意类型的最内层嵌套类型
template <typename T>
struct inner_type
{
    using type = T;
};

// vector特化：递归提取元素的最内层类型
template <typename T>
struct inner_type<std::vector<T>>
{
    using type = typename inner_type<T>::type;
};

// 简化别名
template<typename T>
using inner_type_t = typename inner_type<T>::type;

// ------------------------------
// 提取键的最内层类型的trait
// ------------------------------
template <typename T>
struct inner_key_type
{
    // 默认：非关联容器的键类型即为自身（可根据需求调整）
    using type = T;
};

// map特化：递归提取键的最内层类型
template <typename Key, typename Val>
struct inner_key_type<std::map<Key, Val>>
{
    using type = typename inner_type<Key>::type;
};

// 简化别名
template<typename T>
using inner_key_type_t = typename inner_key_type<T>::type;

// ------------------------------
// 提取值的最内层类型的trait
// ------------------------------
template <typename T>
struct inner_value_type
{
    // 默认：复用inner_type处理vector或普通类型
    using type = typename inner_type<T>::type;
};

// map特化：递归提取值的最内层类型
template <typename Key, typename Val>
struct inner_value_type<std::map<Key, Val>>
{
    using type = typename inner_type<Val>::type;
};

// 简化别名
template<typename T>
using inner_value_type_t = typename inner_value_type<T>::type;

// ------------------------------
// 定义Concept约束
// ------------------------------
// 约束vector最内层类型为int
template<typename T>
concept VectorInnerIsInt = std::same_as<inner_type_t<T>, int>;

// 同时约束map的键和值最内层类型为int
template<typename T>
concept MapInnerKeyAndValueAreInt = 
    std::same_as<inner_key_type_t<T>, int> && 
    std::same_as<inner_value_type_t<T>, int>;

// ------------------------------
// 测试函数
// ------------------------------
template<typename Arg>
requires VectorInnerIsInt<Arg>
auto handle_vector(Arg arg)
{
    // 处理嵌套vector逻辑
}

template<typename Arg>
requires MapInnerKeyAndValueAreInt<Arg>
auto handle_map(Arg arg)
{
    // 处理嵌套map逻辑
}

int main() {
    // vector测试用例
    std::vector<int> int_vec{1, 2, 3};
    std::vector<std::vector<int>> nested_int_vec{{1,2}, {3,4}};
    handle_vector(int_vec);
    handle_vector(nested_int_vec);

    // map测试用例
    std::map<int, int> int_map{{1,2}, {3,4}};
    std::map<std::vector<int>, std::vector<int>> nested_map{{{1}, {2}}, {{3}, {4}}};
    handle_map(int_map);
    handle_map(nested_map); // 键和值的最内层均为int，符合约束
}

核心说明 #

1. 拆分trait：将原有的inner_type拆分为inner_key_type和inner_value_type，避免同一容器类型的特化冲突。
2. 递归提取：针对std::map分别递归提取键和值的最内层类型，复用已有的inner_type处理嵌套容器（比如std::vector<int>作为map键/值的情况）。
3. 组合约束：通过Concept将键和值的约束条件组合，实现同时验证两者的最内层类型。

如果需要支持std::unordered_map等其他关联容器，可添加对应容器的trait特化，逻辑与std::map一致。

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