适用于64位OS /编译器的散列函数，适用于实际上只是4字节int的对象

如何解决适用于64位OS /编译器的散列函数，适用于实际上只是4字节int的对象

我有一个名为Foo的类，它私有地不超过4字节int。如果我将其值返回为8字节的size_t，我是否会搞砸unordered_map<>还是其他？我可以用return foo + foo << 32;之类的东西填充所有位。会更好，还是会更糟，因为所有哈希现在都是0x100000001的倍数？还是return ~foo + foo << 32;会使用全部64位并且也没有公因子呢？

namespace std {
  template<> struct hash<MyNamespace::Foo> {
    typedef size_t result_type;
    typedef MyNamespace::Foo argument_tupe;
    size_t operator() (const MyNamespace::Foo& f ) const { return (size_t) f.u32InternalValue; }
  };
}

解决方法

将增量uint32_t转换为uint64_t的效果很好

unordered_map将为哈希表逐步保留空间。

密钥的较低有效位用于确定存储桶位置，在4个条目/存储桶的示例中，使用较低有效的2位。 具有相同存储桶（存储桶数的倍数）的键的元素链接在一个链表中。带有负载因子的概念。

// 4 Buckets example

******** ******** ******** ******** ******** ******** ******** ******XX

bucket 00 would contains keys like {0,256,200000 ...}
bucket 01 would contains keys like {1,513,4008001 ...}
bucket 10 would contains keys like {2,130,10002 ...}
bucket 11 would contains keys like {3,259,1027,20003,...}

如果您尝试在存储桶中保存其他值，并且其加载因子超过了限制，则将调整表的大小（例如，尝试在具有load_factor = 1.0的4存储桶表中保存第5个元素）。 / p>

因此：

拥有一个uint32_t或一个uint64_t键对您几乎没有影响，直到您到达2 ^ 32个元素的哈希表为止。

会更好，还是会更糟，因为所有哈希现在都是0x100000001的倍数？

直到达到32位溢出（2 ^ 32）哈希表，这才有影响。

增量uint32_t和uint64_t之间的良好密钥转换：

key64 = static_cast<uint64>(key32);

增量uint32_t和uint64_t之间的密钥转换：

key64 = static_cast<uint64>(key32)<<32;

最好是尽可能地保持键，避免一次又一次地使用相同系数的哈希值。例如。在下面的代码中，全为7的键将发生冲突，直到将其调整为16个存储桶为止。

https://onlinegdb.com/r1N7TNySv

#include <iostream>
#include <unordered_map>

using namespace std;

// Print to std output the internal structure of an unordered_map.
template <typename K,typename T>
void printMapStruct(unordered_map<K,T>& map)
{
    cout << "The map has " << map.bucket_count()<< 
        " buckets and max load factor: " << map.max_load_factor() << endl;
    
    for (size_t i=0; i< map.bucket_count(); ++i)
    {
        cout << "    Bucket " << i << ": ";
        for (auto it=map.begin(i); it!=map.end(i); ++it)
        {
            cout << it->first << " ";
        }
        cout << endl;
    }
    cout << endl;
}

// Print the list of bucket sizes by this implementation
void printMapResizes()
{
    cout << "Map bucket counts:"<< endl;
    unordered_map<size_t,size_t> map;
    
    size_t lastBucketSize=0;
    for (size_t i=0; i<1024*1024; ++i)
    {
        if (lastBucketSize!=map.bucket_count())
        {
            cout << map.bucket_count() << " ";
            lastBucketSize = map.bucket_count();
        }
        map.emplace(i,i);
    }
    cout << endl;
}

int main()
{
    unordered_map<size_t,size_t> map;
    
    printMapStruct(map);
    
    map.emplace(0,0);
    map.emplace(1,1);
    printMapStruct(map);
    
    map.emplace(72,72);
    map.emplace(17,17);
    printMapStruct(map);
    
    map.emplace(7,7);
    map.emplace(14,14);
    printMapStruct(map);
    
    printMapResizes();

    return 0;
}

注意存储桶数：

在上面的示例中，存储区计数如下：

1 3 7 17 37 79 167 337 709 1493 3209 6427 12983 26267 53201 107897 218971 444487 902483 1832561

这似乎是有意遵循一系列质数（以最小化冲突）。我不知道背后的功能。

std::unordered_map<> bucket_count() after default rehash