如何通过C++模板根据T的可哈希性自动选择map或unordered_map？

当然可以实现！这种根据类型特性自动适配容器的需求，在C++模板编程里是非常典型的场景，我们可以通过模板元编程的技巧来完成——核心思路就是先检测std::hash<T>是否可用，再根据结果自动选择unordered_map或map。下面给你几种实用的实现方案：

方案1：用类型别名模板自动选择容器（C++11及以上） #

首先我们需要一个类型特性来检测std::hash<T>是否能正常工作，然后用std::conditional_t来自动选择容器类型：

步骤1：实现has_hash类型特性 #

这个特性会帮我们判断给定类型T是否可以被std::hash处理：

#include <type_traits>
#include <unordered_map>
#include <map>

// C++11兼容的hash可用性检测
template <typename T>
struct has_hash {
private:
    // 重载1：如果std::hash<T>可用，会匹配这个版本
    template <typename U>
    static auto test(int) -> decltype(std::hash<U>{}(std::declval<U>()), std::true_type{});
    // 重载2：如果不可用，会匹配这个兜底版本
    template <typename U>
    static std::false_type test(...);
public:
    static constexpr bool value = decltype(test<T>(0))::value;
};

// 方便使用的变量模板（C++14及以上，C++11可以用has_hash<T>::value代替）
template <typename T>
constexpr bool has_hash_v = has_hash<T>::value;

步骤2：定义自动选择容器的类型别名 #

用std::conditional_t根据has_hash_v<T>的结果选择容器：

template <typename Key, typename Value>
using auto_map = typename std::conditional<
    has_hash_v<Key>,
    std::unordered_map<Key, Value>,
    std::map<Key, Value>
>::type;

// C++14及以上可以简化为：
// template <typename Key, typename Value>
// using auto_map = std::conditional_t<has_hash_v<Key>, std::unordered_map<Key, Value>, std::map<Key, Value>>;

步骤3：在你的类中使用 #

现在只需要在模板类里直接用auto_map即可：

template <typename T>
class MyClass {
private:
    auto_map<T, int> container_; // 自动选择unordered_map（如果hash可用）或map
public:
    // 示例成员函数
    void insert(const T& key, int value) {
        container_.emplace(key, value);
    }

    int get(const T& key) const {
        return container_.at(key);
    }
};

方案2：结合if constexpr实现容器专属逻辑（C++17及以上） #

如果你的类需要根据容器类型做不同的操作（比如unordered_map的bucket相关方法），可以用C++17的if constexpr在编译时分支处理：

template <typename T>
class MyClass {
private:
    using Container = std::conditional_t<has_hash_v<T>, std::unordered_map<T, int>, std::map<T, int>>;
    Container container_;
public:
    void print_container_info() const {
        if constexpr (has_hash_v<T>) {
            // 只有unordered_map才有bucket_count方法，编译时只会保留这个分支
            std::cout << "容器类型：std::unordered_map，桶数量：" << container_.bucket_count() << "\n";
        } else {
            // map没有bucket，输出其他信息
            std::cout << "容器类型：std::map，元素数量：" << container_.size() << "\n";
        }
    }
};

关键注意事项 #

• map的依赖要求：当回退到std::map时，你的Key类型必须支持operator<（或者你需要在auto_map里指定自定义比较器）。可以加静态断言来提前提示错误：

  template <typename T>
  class MyClass {
  private:
      using Container = auto_map<T, int>;
      Container container_;
  
      // 静态断言：如果用map，Key必须支持比较
      static_assert(has_hash_v<T> || std::is_invocable_v<std::less<T>, const T&, const T&>,
                    "错误：当std::hash<T>不可用时，Key类型必须支持operator<（或提供自定义比较器）");
  };
  

• 自定义hash支持：如果你的自定义类型有std::hash的特化（比如下面的例子），has_hash_v会自动检测到并选择unordered_map：

  struct MyCustomType { int id; };
  
  // 为MyCustomType特化std::hash
  namespace std {
      template <>
      struct hash<MyCustomType> {
          size_t operator()(const MyCustomType& obj) const {
              return std::hash<int>()(obj.id);
          }
      };
  }
  
  // 此时MyClass<MyCustomType>会使用std::unordered_map
  

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