2. Boost Unordered Translation (zh_Hans)
3. Doc / Modules / Root / Pages / Hash Equality (adoc)
4. English
5. Zen

1 :3
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — :idprefix: hash_equality_ 25/10000 · 25
2 :5
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — = Equality Predicates and Hash Functions 40/10000 · 40
3 :7
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — While the associative containers use an ordering relation to specify how the elements are stored, the unordered associative containers use an equality predicate and a hash function. For example, `xref:reference/unordered_map.adoc[boost::unordered_map]` is declared as: 268/10000 · 268
4 :12
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```cpp template < class Key, class Mapped, class Hash = boost::hash<Key>, class Pred = std::equal_to<Key>, class Alloc = std::allocator<std::pair<Key const, Mapped> > > class unordered_map; ``` 193/10000 · 193
5 :21
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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: 263/10000 · 263
6 :25
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ``` 75/10000 · 75
7 :30
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory. 97/10000 · 97
8 :32
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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: 233/10000 · 233
9 :34
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```cpp struct iequal_to { bool operator()(std::string const& x, std::string const& y) const { return boost::algorithm::iequals(x, y, std::locale()); } }; 153/10000 · 153
10 :44
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — struct ihash { std::size_t operator()(std::string const& x) const { std::size_t seed = 0; std::locale locale; 109/10000 · 109
11 :51
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); } 126/10000 · 126
12 :57
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — return seed; } }; ``` 21/10000 · 21
13 :62
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ``` 137/10000 · 137
14 :68
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 185/10000 · 185
15 :71
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Be careful when using the equality (`==`) operator with custom equality 71/10000 · 71
16 :72
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 453/10000 · 453
17 :79
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Custom Types 12/10000 · 12
18 :81
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Similarly, a custom hash function can be used for custom types: 63/10000 · 63
:83 :83
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```cpp struct point { int x; int y; }; 38/10000 · 38
:89 :89
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; } 90/10000 · 90