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

Filters

• Untranslated strings • state:empty
• Unfinished strings • state:<translated
• Translated strings • state:>=translated
• Strings marked for edit • state:needs-editing
• Strings with suggestions • has:suggestion
• Strings with variants • has:variant
• Strings with screenshots • has:screenshot
• Strings with labels • has:label
• Strings with context • has:context
• Unfinished strings without suggestions • state:<translated AND NOT has:suggestion
• Strings with comments • has:comment
• Strings with any failing checks • has:check
• Approved strings • state:approved
• Strings waiting for review • state:translated

state:>=translated

Position and priority

• Position and priority
• Position
• Priority
• Labels
• Source string
• Target string
• String age
• Last updated
• Number of words
• Number of comments
• Number of failing checks
• Key
• String location
• Component and priority

	Translation	Key	Source string	Target string
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		:idprefix: hash_equality_	:idprefix: hash_equality_
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		:idprefix: hash_equality_	:idprefix: hash_equality_
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		= Equality Predicates and Hash Functions	= Equality Predicates and Hash Functions
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		= Equality Predicates and Hash Functions	= 相等性谓词与哈希函数
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		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:
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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]`的声明如下：
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		```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; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		```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>
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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:	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:
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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 哈希^]，可以这样写：
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```	```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		```cpp boost::unordered_map<std::string, int, hash::fnv_1a> dictionary; ```	```cpp boost::unordered_map<std::string, int,="" hash::fnv_1a=""> dictionary; ```</std::string,>
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.	There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		There is an link:../../../examples/fnv1.hpp[implementation of FNV-1a^] in the examples directory.	examples 目录中有一个链接：../../../examples/fnv1.hpp[implementation of FNV-1a^]
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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:	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:
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		```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& x, std::string const& y) const { return boost::algorithm::iequals(x, y, std::locale()); } };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		```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()); } };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		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& x) const { std::size_t seed = 0; std::locale locale;
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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;
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		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)); }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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)); }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		return seed; } }; ```	return seed; } }; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		return seed; } }; ```	return seed; } }; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ```	Which you can then use in a case insensitive dictionary: ```cpp boost::unordered_map<std::string, int, ihash, iequal_to> idictionary; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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,>
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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.	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.
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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^] 处示例的简化版本，该示例支持其他区域设置和字符串类型。
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Be careful when using the equality (`==`) operator with custom equality	Be careful when using the equality (`==`) operator with custom equality
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Be careful when using the equality (`==`) operator with custom equality	在使用自定义相等谓词时，请谨慎使用相等（==）运算符
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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.	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 Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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），则可能会遇到问题。
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Custom Types	Custom Types
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Custom Types	自定义类型
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Similarly, a custom hash function can be used for custom types:	Similarly, a custom hash function can be used for custom types:
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Similarly, a custom hash function can be used for custom types:	类似地，自定义类型也可使用自定义哈希函数：
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English	:83	```cpp struct point { int x; int y; };	```cpp struct point { int x; int y; };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)	:83	```cpp struct point { int x; int y; };	```cpp struct point { int x; int y; };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English	:89	bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }	bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)	: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; }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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; } };	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; } };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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 Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		boost::unordered_multiset<point, point_hash> points; ```	boost::unordered_multiset<point, point_hash> points; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		boost::unordered_multiset<point, point_hash> points; ```	boost::unordered_multiset<point, point_hash=""> points; ```</point,>
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — 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:	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:
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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^]，我们可以扩展它以支持该类型，从而无需显式给出哈希函数：
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English	:111	```cpp struct point { int x; int y; };	```cpp struct point { int x; int y; };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)	:111	```cpp struct point { int x; int y; };	```cpp struct point { int x; int y; };
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English	:117	bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }	bool operator==(point const& p1, point const& p2) { return p1.x == p2.x && p1.y == p2.y; }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)	: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; }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		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& p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; }
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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 Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		boost::unordered_multiset<point> points; ```	boost::unordered_multiset<point> points; ```
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		boost::unordered_multiset<point> points; ```	boost::unordered_multiset<point> points; ```</point>
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		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.	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.
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		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。
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Method	Method
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Method	方法
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Description	Description
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Description	描述
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		`hasher hash_function() const`	`hasher hash_function() const`
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		`hasher hash_function() const`	`hasher hash_function() const`
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Returns the container's hash function.	Returns the container's hash function.
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Returns the container's hash function.	返回容器的哈希函数。
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		`key_equal key_eq() const`	`key_equal key_eq() const`
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		`key_equal key_eq() const`	`key_equal key_eq() const`
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — English		Returns the container's key equality function..	Returns the container's key equality function..
	Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Hash Equality (adoc) — Chinese (Simplified Han script)		Returns the container's key equality function..	返回容器的键相等性函数。