关于通过依赖boost::hash特化std::hash模板以支持std::pair<int,int>的合法性问询

嘿，这个问题抓得相当精准，咱们一步步拆解来理清楚合法性的核心问题：

首先先回顾你最初踩的坑——直接特化std::hash<std::pair<int, int>>确实不合法，核心依据是C++23 [namespace.std]#2的条款，咱们把关键内容贴出来明确：

Unless explicitly prohibited, a program may add a template specialization for any standard library class template to namespace std provided that (a) the added declaration depends on at least one program-defined type and (b) the specialization meets the standard library requirements for the original template.

这里的核心门槛是**「程序定义类型（program-defined type）」——C++标准里的这个概念，特指你自己编写的代码所定义的类型**，第三方库（比如Boost）的类型/模板特化不算，标准库自带的类型更不算。

那回到你提出的那个特化方案：

#include <unordered_set>
#include <boost/container_hash/hash.hpp>

template <class T>
requires requires (T value) { boost::hash<T>()(value); }
struct std::hash<T> {
    std::size_t operator()(const T& value) const {
        return boost::hash<T>()(value);
    }
};

你认为T依赖boost::hash<T>，但这里有个关键误区：boost::hash<T>是Boost库提供的模板/特化，属于第三方库的代码，完全不属于你的程序定义的类型。当你用这个特化来支持std::pair<int, int>时，整个特化的依赖链里没有任何属于你程序的自定义类型——std::pair<int,int>是标准库类型，boost::hash<std::pair<int,int>>是Boost的模板特化，所以这个特化依然不满足[namespace.std]的(a)条件，本质上还是非法的。

那怎么合法地让std::unordered_set支持std::pair<int, int>？给你两个稳妥的方案：

方案1：给unordered_set指定自定义哈希器（最推荐） #

根本不需要碰std::hash的特化，直接在声明unordered_set时把boost::hash作为哈希函数参数：

#include <unordered_set>
#include <boost/container_hash/hash.hpp>

int main() {
    std::unordered_set<std::pair<int, int>, boost::hash<std::pair<int, int>>> my_set = { {1,1}, {2,2}, {3,3} };
}

这种方式完全符合标准，没有任何越界操作，简单直接，还能避免修改std命名空间带来的潜在问题。

方案2：用自定义wrapper类型（合法特化std::hash的方式） #

如果你一定要通过特化std::hash来实现，那得定义一个自己的wrapper类型（程序定义类型），把std::pair包起来：

#include <unordered_set>
#include <boost/container_hash/hash.hpp>

// 这是你的程序定义类型，完全受你控制
template <typename First, typename Second>
struct PairWrapper {
    std::pair<First, Second> value;
    
    // 加构造函数让它用起来和std::pair差不多
    PairWrapper(First f, Second s) : value(std::move(f), std::move(s)) {}
    // 隐式转换为std::pair，方便兼容现有代码
    operator const std::pair<First, Second>&() const { return value; }
    // 定义==运算符满足unordered_set的相等性要求
    bool operator==(const PairWrapper& other) const { return value == other.value; }
};

// 现在这个特化是合法的，因为它依赖于你定义的PairWrapper类型
template <typename First, typename Second>
struct std::hash<PairWrapper<First, Second>> {
    std::size_t operator()(const PairWrapper<First, Second>& wrapper) const {
        return boost::hash<std::pair<First, Second>>()(wrapper.value);
    }
};

int main() {
    std::unordered_set<PairWrapper<int, int>> my_set = { {1,1}, {2,2}, {3,3} };
}

这个特化完全满足[namespace.std]的(a)条件，是标准允许的操作。

总结一下：你之前的那个特化方案不符合标准要求，因为Boost库的类型不属于「程序定义类型」。推荐用方案1，简单高效还没风险。

内容来源于stack exchange