Какова хэш-функция по умолчанию, используемая в C++ std::unordered map?
Я использую
unordered_map<string, int>
и
unordered_map<int, int>
какая хэш-функция используется в каждом случае и какова вероятность столкновения в каждом случае? Я буду вставлять уникальную строку и уникальный int в качестве ключей в каждом случае соответственно.
мне интересно знать алгоритм хэш-функции в случае клавиш string и int и их статистику столкновений.
2 ответов
объект function std::hash<>
это.
стандартные специализации существуют для всех встроенных типов и некоторых других стандартных типов библиотек
такие как std::string
и std::thread
. Полный список см. по ссылке.
для других типов, которые будут использоваться в std::unordered_map
, вам придется специализироваться std::hash<>
или создать свой собственный объект функции.
вероятность столкновения полностью зависит от реализации, но учитывая тот факт, что целые числа ограничены между определенным диапазоном, в то время как теоретически бесконечно длинные строки, Я бы сказал, что есть гораздо больше шансов на столкновение со строками.
что касается реализации в GCC, специализация для встроенных типов просто возвращает битовый шаблон. Вот как они определены в bits/functional_hash.h
:
/// Partial specializations for pointer types.
template<typename _Tp>
struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
{
size_t
operator()(_Tp* __p) const noexcept
{ return reinterpret_cast<size_t>(__p); }
};
// Explicit specializations for integer types.
#define _Cxx_hashtable_define_trivial_hash(_Tp) \
template<> \
struct hash<_Tp> : public __hash_base<size_t, _Tp> \
{ \
size_t \
operator()(_Tp __val) const noexcept \
{ return static_cast<size_t>(__val); } \
};
/// Explicit specialization for bool.
_Cxx_hashtable_define_trivial_hash(bool)
/// Explicit specialization for char.
_Cxx_hashtable_define_trivial_hash(char)
/// ...
специализация на std::string
определено как:
#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
/// std::hash specialization for string.
template<>
struct hash<string>
: public __hash_base<size_t, string>
{
size_t
operator()(const string& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(), __s.length()); }
};
некоторые дальнейшие поиски приводят нас кому:
struct _Hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(0xc70f6907UL))
{ return _Hash_bytes(__ptr, __clength, __seed); }
...
};
...
// Hash function implementation for the nontrivial specialization.
// All of them are based on a primitive that hashes a pointer to a
// byte array. The actual hash algorithm is not guaranteed to stay
// the same from release to release -- it may be updated or tuned to
// improve hash quality or speed.
size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
_Hash_bytes
внешняя функция из libstdc++
. Немного больше поисков привело меня к этот файл, в которой говорится:
// This file defines Hash_bytes, a primitive used for defining hash
// functions. Based on public domain MurmurHashUnaligned2, by Austin
// Appleby. http://murmurhash.googlepages.com/
таким образом, алгоритм хэширования по умолчанию GCC использует для строк MurmurHashUnaligned2.
хотя алгоритмы хэширования зависят от компилятора, я представлю его для GCC C++11. @Avidan Borisov проницательно обнаружил что алгоритм хеширования GCC, используемый для строк, является "MurmurHashUnaligned2" Остина Эпплби. Я немного поискал и нашел зеркальную копию GCC на Github. Таким образом:
функции хэширования GCC C++11, используемые для unordered_map
(шаблон хэш-таблицы) и unordered_set
(шаблон набора хэшей), по-видимому, следующим образом.
- спасибо Авидану Борисову для его фоновых исследований, которые по вопросу какие хэш-функции gcc C++11 используются, заявив, что GCC использует реализацию "MurmurHashUnaligned2" Остина Эпплби (http://murmurhash.googlepages.com/).
- в файле "gcc / libstdc++ - v3/libsupc++ / hash_bytes.cc", здесь (https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/hash_bytes.cc)я нашел реализации. Вот один для возвращаемого значения "32-bit size_t", например (вытащил 11 Aug 2017)
код:
// Implementation of Murmur hash for 32-bit size_t.
size_t _Hash_bytes(const void* ptr, size_t len, size_t seed)
{
const size_t m = 0x5bd1e995;
size_t hash = seed ^ len;
const char* buf = static_cast<const char*>(ptr);
// Mix 4 bytes at a time into the hash.
while (len >= 4)
{
size_t k = unaligned_load(buf);
k *= m;
k ^= k >> 24;
k *= m;
hash *= m;
hash ^= k;
buf += 4;
len -= 4;
}
// Handle the last few bytes of the input array.
switch (len)
{
case 3:
hash ^= static_cast<unsigned char>(buf[2]) << 16;
[[gnu::fallthrough]];
case 2:
hash ^= static_cast<unsigned char>(buf[1]) << 8;
[[gnu::fallthrough]];
case 1:
hash ^= static_cast<unsigned char>(buf[0]);
hash *= m;
};
// Do a few final mixes of the hash.
hash ^= hash >> 13;
hash *= m;
hash ^= hash >> 15;
return hash;
}
для дополнительных функций хэширования, включая djb2
, и 2 версии функций хеширования K&R (один, по-видимому, ужасный, один довольно хороший), см. Мой другой ответ здесь: https://stackoverflow.com/a/45641002/4561887.