Exit Zen
5
:21
English
The hash function comes first as you might want to change the hash function but not the equality predicate. For example, if you wanted to use the https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash[FNV-1a hash^] you could write:
147/2630 · 263
6
:25
English
```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```
96/750 · 75
7
:30
English
There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.
71/970 · 97
8
:32
English
If you wish to use a different equality function, you will also need to use a matching hash function. For example, to implement a case insensitive dictionary you need to define a case insensitive equality predicate and hash function:
6/2330 · 233
9
:34
English
```cpp struct iequal_to { bool operator()(std::string const& x, std::string const& y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
161/1530 · 153
10
:44
English
struct ihash { std::size_t operator()(std::string const& x) const { std::size_t seed = 0; std::locale locale;
113/1090 · 109
11
:51
English
for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); }
126/1260 · 126
12
:57
English
return seed; } }; ```
21/210 · 21
13
:62
English
Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ```
124/1370 · 137
14
:68
English
This is a simplified version of the example at link:../../../examples/case_insensitive.hpp[/libs/unordered/examples/case_insensitive.hpp^] which supports other locales and string types.
122/1850 · 185
15
:71
English
Be careful when using the equality (`==`) operator with custom equality
26/710 · 71
16
:72
English
predicates, especially if you're using a function pointer. If you compare two containers with different equality predicates then the result is undefined. For most stateless function objects this is impossible - since you can only compare objects with the same equality predicate you know the equality predicates must be equal. But if you're using function pointers or a stateful equality predicate (e.g. `boost::function`) then you can get into trouble.
162/4530 · 453
17
:79
English
Custom Types
5/120 · 12
18
:81
English
Similarly, a custom hash function can be used for custom types:
21/630 · 63
:83
:83
English
```cpp struct point { int x; int y; };
38/380 · 38
:89
:89
English
bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
106/900 · 90
21
:94
English
struct point_hash { std::size_t operator()(point const& p) const { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; } };
174/1700 · 170
22
:105
English
boost::unordered_multiset<point, point_hash> points; ```
68/560 · 56
23
:108
English
Since the default hash function is link:../../../../container_hash/index.html[Boost.Hash^], we can extend it to support the type so that the hash function doesn't need to be explicitly given:
93/1910 · 191
:111
:111
English
```cpp struct point { int x; int y; };
38/380 · 38