如何偏特化std::hash模板？通用list迭代器哈希实现问题

首先，以下代码编译失败，因为标准库未提供std::list<int>::iterator的std::hash特化：

#include <list>
#include <string>
#include <unordered_map>

int main() {
    std::list<int> myList = {4, 1, 3, 2};
    std::unordered_map<std::list<int>::iterator, std::string> myMap;
    myMap[myList.begin()] = "first element";
}

为std::list<int>::iterator手动定义std::hash全特化后，代码可正常运行：

template<>
class std::hash<std::list<int>::iterator> {
public:
    size_t operator()(std::list<int>::iterator const& it) const noexcept {
        return hash<int*>()(&*it);
    }
};

但尝试将该特化泛化为任意std::list<T>::iterator时，如下代码会触发编译器静态断言失败：

template<typename T>
class std::hash<std::list<T>::iterator> {
public:
    size_t operator()(std::list<T>::iterator const& it) const noexcept {
        return hash<T*>()(&*it);
    }
};

为什么泛化实现无效？ #

问题出在C++类模板特化的语法规则上：std::list<T>::iterator是依赖于模板参数的嵌套类型，直接将其作为std::hash的部分特化参数时，编译器无法识别这是合法的部分特化形式。

C++要求类模板的部分特化必须使用符合特定模式的模板参数（如简单模板参数、指针/引用类型等），而嵌套依赖类型无法被编译器解析为std::hash特化的匹配模式，最终这段代码会被当作一个独立的类模板定义，而非对std::hash的特化，因此标准库的默认静态断言（检查是否存在有效哈希特化）会触发失败。

如何为任意list迭代器定义std::hash？ #

有两种可靠的解决方式：

方式1：基于模板模板参数的合法部分特化 #

通过明确指定std::list的全部模板参数（元素类型T和分配器Alloc），并使用typename关键字标记嵌套类型，编译器就能正确识别这是std::hash的部分特化：

// 为普通迭代器特化
template<typename T, typename Alloc>
class std::hash<typename std::list<T, Alloc>::iterator> {
public:
    size_t operator()(typename std::list<T, Alloc>::iterator const& it) const noexcept {
        return std::hash<T*>()(&*it);
    }
};

// 为const迭代器特化（按需添加）
template<typename T, typename Alloc>
class std::hash<typename std::list<T, Alloc>::const_iterator> {
public:
    size_t operator()(typename std::list<T, Alloc>::const_iterator const& it) const noexcept {
        return std::hash<const T*>()(&*it);
    }
};

方式2：自定义哈希函数（推荐） #

避免修改std命名空间，自定义一个通用的列表迭代器哈希类，在声明unordered_map时指定为哈希函数参数：

#include <iterator>
#include <type_traits>

template<typename Iter>
struct ListIteratorHash {
    size_t operator()(Iter const& it) const noexcept {
        using ValueType = typename std::iterator_traits<Iter>::value_type;
        // 自动区分普通迭代器和const迭代器
        if constexpr (std::is_const_v<typename std::iterator_traits<Iter>::pointer>) {
            return std::hash<const ValueType*>()(&*it);
        } else {
            return std::hash<ValueType*>()(&*it);
        }
    }
};

// 使用示例
int main() {
    std::list<int> myList = {4, 1, 3, 2};
    std::unordered_map<
        std::list<int>::iterator, 
        std::string, 
        ListIteratorHash<std::list<int>::iterator>
    > myMap;
    myMap[myList.begin()] = "first element";
}

这种方式更符合C++的设计规范，同时通过iterator_traits实现了对普通/const迭代器的兼容。

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