Zen

Translation

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:
109/2680 · 268

Sign in to save translations.

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:
类似地，自定义类型也可使用自定义哈希函数：
English Chinese (Simplified Han script) Actions
= 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
自定义类型
Returns the container's key equality function..
返回容器的键相等性函数。

Loading…

User avatar admin

Translation uploaded
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:
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:的声明如下：
06/05/2026
User avatar admin

String added in the repository
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:
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:
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
49583
Source string location
:7
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 3 pending