Zen

Translation

```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; ```
236/1930 · 193

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:idprefix: hash_equality_
:idprefix: hash_equality_
= Equality Predicates and Hash Functions
= 相等性谓词与哈希函数
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; };
English Chinese (Simplified Han script) Actions
:idprefix: hash_equality_
:idprefix: hash_equality_
= Equality Predicates and Hash Functions
= 相等性谓词与哈希函数
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），则可能会遇到问题。
`hasher hash_function() const`
`hasher hash_function() const`
Returns the container's hash function.
返回容器的哈希函数。

Loading…

User avatar admin

Translation uploaded
```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<Kkey>, class Pred = std::equal_to<Kkey>, class Alloc = std::allocator<std::pair<Kkey const, Mapped> > >="" mapped=""> &gt; &gt; class unordered_map; ```</std::pair<key></key></key>
06/05/2026
User avatar admin

String added in the repository
```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 < 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; ```
06/05/2026
Browse all string changes

Things to check

Consecutive duplicated words

The following word is duplicated: gt;

Reset

Glossary

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

String information

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