如何为小于size_t尺寸的结构体高效生成哈希值？

我有一个包含五个std::uint8_t成员的结构体MyStruct，我的软件仅支持64位构建，不支持32位版本。我希望将该结构体用作unordered_map的键，请问能否通过添加三个额外字节将其补全至64位，再将结构体强制转换为size_t来安全生成哈希值？示例代码如下：

struct MyStruct
{
    std::uint8_t v1 = 0;
    std::uint8_t v2 = 0;
    std::uint8_t v3 = 0;
    std::uint8_t v4 = 0;
    std::uint8_t v5 = 0;
    std::uint8_t pack1 = 255;
    std::uint8_t pack2 = 255;
    std::uint8_t pack3 = 255;
};

namespace std
{
template <>
struct hash<MyStruct>
{
    size_t operator()(const MyStruct &s) const
    {
        static_assert(sizeof(size_t) == 8);
        static_assert(sizeof(MyStruct) == 8);
        const size_t *memptr = reinterpret_cast<const size_t*>(&s);
        return *memptr;
    }
};
}

这种做法存在明显安全风险，不推荐使用，核心原因如下：

• 结构体布局的不确定性：即便手动添加了三个字节，编译器仍可能根据平台对齐规则在成员间插入填充字节，导致sizeof(MyStruct)不等于8。虽然你用static_assert做了检查，但不同编译器、甚至同一编译器的不同编译选项都可能改变结构体布局，后续迭代中很容易触发断言失败。
• 字节序依赖问题：直接将结构体转成size_t完全依赖平台字节序（大端/小端）。如果未来软件需要兼容不同字节序的64位平台（比如x86_64是小端，部分ARM64配置为大端），相同的成员值会生成不同哈希，导致unordered_map行为混乱。
• 未定义行为风险：C++标准明确规定，reinterpret_cast将结构体指针转为size_t指针属于未定义行为，除非结构体内存布局与size_t完全兼容。当前平台可能正常运行，但编译器版本更新、编译选项调整都可能打破这种脆弱的兼容性。

更安全的替代方案 #

方案1：手动组合成员生成哈希

直接基于五个有效成员的值构建哈希，完全避开结构体布局依赖：

namespace std
{
template <>
struct hash<MyStruct>
{
    size_t operator()(const MyStruct &s) const
    {
        static_assert(sizeof(size_t) == 8);
        size_t hash_val = 0;
        // 按固定顺序合并字节，可根据需求调整移位位置
        hash_val |= static_cast<size_t>(s.v1) << 56;
        hash_val |= static_cast<size_t>(s.v2) << 48;
        hash_val |= static_cast<size_t>(s.v3) << 40;
        hash_val |= static_cast<size_t>(s.v4) << 32;
        hash_val |= static_cast<size_t>(s.v5) << 24;
        // 额外的pack成员值固定为255，不影响哈希唯一性，无需参与计算
        return hash_val;
    }
};
}

方案2：使用哈希组合函数（C++17及以上）

借助标准库哈希工具，更优雅地组合成员哈希值：

#include <functional>

namespace std
{
template <>
struct hash<MyStruct>
{
    size_t operator()(const MyStruct &s) const
    {
        size_t seed = hash<uint8_t>{}(s.v1);
        hash_combine(seed, s.v2);
        hash_combine(seed, s.v3);
        hash_combine(seed, s.v4);
        hash_combine(seed, s.v5);
        return seed;
    }

private:
    // 自定义哈希组合函数，C++标准库未直接提供
    template <typename T>
    void hash_combine(size_t& seed, const T& val) const
    {
        seed ^= hash<T>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }
};
}

必要补充：定义相等运算符 #

要将MyStruct用作unordered_map的键，必须为其定义==运算符，确保对象比较逻辑符合预期：

bool operator==(const MyStruct& lhs, const MyStruct& rhs)
{
    return lhs.v1 == rhs.v1 && lhs.v2 == rhs.v2 && lhs.v3 == rhs.v3 &&
           lhs.v4 == rhs.v4 && lhs.v5 == rhs.v5;
    // pack成员值固定，无需参与比较
}

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