Zen

Translation

Similarly, a custom hash function can be used for custom types:
21/630 · 63

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
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:
关联容器使用排序关系来规定元素的存储方式，而无序关联容器则依赖相等性谓词与哈希函数。例如， `xref:reference/unordered_map.adoc[boost::unordered_map]`的声明如下：
```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; ```
```cpp template &lt; class Key, class Mapped, class Hash = boost::hash<key>, class Pred = std::equal_to<key>, class Alloc = std::allocator<std::pair<key const,="" mapped=""> &gt; &gt; class unordered_map; ```</std::pair<key></key></key>
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:
哈希函数放在首位，因为你可能只想更改哈希函数而不想更改相等谓词。例如，如果你想使用 https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash[FNV-1a 哈希^]，可以这样写：
```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```
```cpp boost::unordered_map<std::string, int,="" hash::fnv_1a=""> dictionary; ```</std::string,>
There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.
examples 目录中有一个链接：../../../examples/fnv1.hpp[implementation of FNV-1a^]
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:
```cpp
```cpp struct iequal_to { bool operator()(std::string const& x, std::string const& y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
```cpp struct iequal_to { bool operator()(std::string const&amp; x, std::string const&amp; y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
struct ihash { std::size_t operator()(std::string const& x) const { std::size_t seed = 0; std::locale locale;
struct ihash { std::size_t operator()(std::string const&amp; x) const { std::size_t seed = 0; std::locale locale;
for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); }
for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); }
return seed; } }; ```
return seed; } }; ```
Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ```
然后你可以在不区分大小写的字典中使用它：```cpp boost::unordered_map<std::string, int,="" ihash,="" iequal_to=""> idictionary; ```</std::string,>
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.
这是 link:../../../examples/case_insensitive.hpp[/libs/unordered/examples/case_insensitive.hpp^] 处示例的简化版本，该示例支持其他区域设置和字符串类型。
Be careful when using the equality (`==`) operator with custom equality
在使用自定义相等谓词时，请谨慎使用相等（==）运算符
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.
在使用自定义相等谓词（特别是函数指针）时请务必小心。如果你用不同的相等谓词比较两个容器，结果是未定义的。对于大多数无状态函数对象而言，这种情况不可能发生——因为你只能使用相同的相等谓词来比较对象，所以两个相等谓词必然相等。但如果你使用的是函数指针或有状态的相等谓词（例如 boost::function），则可能会遇到问题。
Custom Types
自定义类型
Similarly, a custom hash function can be used for custom types:
类似地，自定义类型也可使用自定义哈希函数：
:83
```cpp struct point { int x; int y; };
```cpp struct point { int x; int y; };
:89
bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
bool operator==(point const&amp; p1, point const&amp; p2) { return p1.x == p2.x &amp;&amp; p1.y == p2.y; }
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; } };
struct point_hash { std::size_t operator()(point const&amp; p) const { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; } };
boost::unordered_multiset<point, point_hash> points; ```
boost::unordered_multiset<point, point_hash=""> points; ```</point,>
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:
由于默认哈希函数是 link:../../../../container_hash/index.html[Boost.Hash^]，我们可以扩展它以支持该类型，从而无需显式给出哈希函数：
:111
```cpp struct point { int x; int y; };
```cpp struct point { int x; int y; };
:117
bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
bool operator==(point const&amp; p1, point const&amp; p2) { return p1.x == p2.x &amp;&amp; p1.y == p2.y; }
std::size_t hash_value(point const& p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; }
std::size_t hash_value(point const&amp; p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; }
boost::unordered_multiset<point> points; ```
boost::unordered_multiset<point> points; ```</point>
See the link:../../../../container_hash/index.html[Boost.Hash documentation^] for more detail on how to do this. Remember that it relies on extensions to the standard - so it won't work for other implementations of the unordered associative containers, you'll need to explicitly use Boost.Hash.
有关如何执行此操作的更多详细信息，请参阅 link:../../../../container_hash/index.html[Boost.Hash 文档^]。请记住，它依赖于标准扩展—因此它不适用于无序关联容器的其他实现，你需要显式使用 Boost.Hash。
Method
方法
Description
描述
`hasher hash_function() const`
`hasher hash_function() const`
Returns the container's hash function.
返回容器的哈希函数。
`key_equal key_eq() const`
`key_equal key_eq() const`
Key English Chinese (Simplified Han script) Actions
`key_equal key_eq() const`
`key_equal key_eq() const`
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:
关联容器使用排序关系来规定元素的存储方式，而无序关联容器则依赖相等性谓词与哈希函数。例如， `xref:reference/unordered_map.adoc[boost::unordered_map]`的声明如下：
```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; ```
```cpp template &lt; class Key, class Mapped, class Hash = boost::hash<key>, class Pred = std::equal_to<key>, class Alloc = std::allocator<std::pair<key const,="" mapped=""> &gt; &gt; class unordered_map; ```</std::pair<key></key></key>
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:
哈希函数放在首位，因为你可能只想更改哈希函数而不想更改相等谓词。例如，如果你想使用 https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash[FNV-1a 哈希^]，可以这样写：
```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```
```cpp boost::unordered_map<std::string, int,="" hash::fnv_1a=""> dictionary; ```</std::string,>
There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.
examples 目录中有一个链接：../../../examples/fnv1.hpp[implementation of FNV-1a^]
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:
```cpp
```cpp struct iequal_to { bool operator()(std::string const& x, std::string const& y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
```cpp struct iequal_to { bool operator()(std::string const&amp; x, std::string const&amp; y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
struct ihash { std::size_t operator()(std::string const& x) const { std::size_t seed = 0; std::locale locale;
struct ihash { std::size_t operator()(std::string const&amp; x) const { std::size_t seed = 0; std::locale locale;
for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); }
for(std::string::const_iterator it = x.begin(); it != x.end(); ++it) { boost::hash_combine(seed, std::toupper(*it, locale)); }
return seed; } }; ```
return seed; } }; ```
Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ```
然后你可以在不区分大小写的字典中使用它：```cpp boost::unordered_map<std::string, int,="" ihash,="" iequal_to=""> idictionary; ```</std::string,>
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.
这是 link:../../../examples/case_insensitive.hpp[/libs/unordered/examples/case_insensitive.hpp^] 处示例的简化版本，该示例支持其他区域设置和字符串类型。
Be careful when using the equality (`==`) operator with custom equality
在使用自定义相等谓词时，请谨慎使用相等（==）运算符
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.
在使用自定义相等谓词（特别是函数指针）时请务必小心。如果你用不同的相等谓词比较两个容器，结果是未定义的。对于大多数无状态函数对象而言，这种情况不可能发生——因为你只能使用相同的相等谓词来比较对象，所以两个相等谓词必然相等。但如果你使用的是函数指针或有状态的相等谓词（例如 boost::function），则可能会遇到问题。
Custom Types
自定义类型
Similarly, a custom hash function can be used for custom types:
类似地，自定义类型也可使用自定义哈希函数：
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; } };
struct point_hash { std::size_t operator()(point const&amp; p) const { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; } };
boost::unordered_multiset<point, point_hash> points; ```
boost::unordered_multiset<point, point_hash=""> points; ```</point,>
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:
由于默认哈希函数是 link:../../../../container_hash/index.html[Boost.Hash^]，我们可以扩展它以支持该类型，从而无需显式给出哈希函数：
Returns the container's hash function.
返回容器的哈希函数。
:idprefix: hash_equality_
:idprefix: hash_equality_
std::size_t hash_value(point const& p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; }
std::size_t hash_value(point const&amp; p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; }
boost::unordered_multiset<point> points; ```
boost::unordered_multiset<point> points; ```</point>
See the link:../../../../container_hash/index.html[Boost.Hash documentation^] for more detail on how to do this. Remember that it relies on extensions to the standard - so it won't work for other implementations of the unordered associative containers, you'll need to explicitly use Boost.Hash.
有关如何执行此操作的更多详细信息，请参阅 link:../../../../container_hash/index.html[Boost.Hash 文档^]。请记住，它依赖于标准扩展—因此它不适用于无序关联容器的其他实现，你需要显式使用 Boost.Hash。
Method
方法
Description
描述
`hasher hash_function() const`
`hasher hash_function() const`
:111
```cpp struct point { int x; int y; };
```cpp struct point { int x; int y; };
:117
bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
bool operator==(point const&amp; p1, point const&amp; p2) { return p1.x == p2.x &amp;&amp; p1.y == p2.y; }

Loading…

User avatar admin

Translation uploaded
Similarly, a custom hash function can be used for custom types:
Similarly, a custom hash function can be used for custom types:类似地，自定义类型也可使用自定义哈希函数：
06/05/2026
User avatar admin

String added in the repository
Similarly, a custom hash function can be used for custom types:
Similarly, a custom hash function can be used for custom types:
06/05/2026
Browse all string changes

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Flags
safe-html, strict-same
Unit identifier
49598
Source string location
:81
String age
06/05/2026
Last updated
06/05/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/hash_equality_zh_Hans.adoc, string 18 pending