Zen

Translation

```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
259/2050 · 205

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
```c++ void reset_stats() noexcept; ```
```c++ void reset_stats() noexcept; ```
Effects:;; Sets to zero the internal statistics kept by the container. Notes:;; Only available if xref:reference/stats.adoc#stats[statistics calculation] is xref:unordered_node_set_boost_unordered_enable_stats[enabled].
效果：将容器内部维护的统计信息归零。
注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] 启用时才可用。
:1282
---
---
Deduction Guides
推导指引
A deduction guide will not participate in overload resolution if any of the following are true:
如果以下任何一条件为真，则推导指引将不参与重载决议：
- It has an `InputIterator` template parameter and a type that does not qualify as an input iterator is deduced for that parameter. - It has an `Allocator` template parameter and a type that does not qualify as an allocator is deduced for that parameter. - It has a `Hash` template parameter and an integral type or a type that qualifies as an allocator is deduced for that parameter. - It has a `Pred` template parameter and a type that qualifies as an allocator is deduced for that parameter.
- 它具有一个 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代器的要求。
- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求。
- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器的要求。
- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。
A `size_­type` parameter type in a deduction guide refers to the `size_­type` member type of the container type deduced by the deduction guide. Its default value coincides with the default value of the constructor selected.
推导指引中的 `size_type` 参数类型指的是由该推导指引所推导出的容器类型的 `size_type` 成员类型。其默认值与所选构造函数的默认值一致。
__iter-value-type__
_iter-value-type_
Equality Comparisons
相等性比较
operator
operator
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator==(const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>
Return `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
若 `x.size() == y.size()` 且对于 `x` 中的每个元素，在 `y` 中均存在一个具有相同键且值相等（使用 `operator==` 比较值类型）的元素，则返回 `true`。
:1316
Notes:;; Behavior is undefined if the two containers don't have equivalent equality predicates.
注意：如果两个容器不具有等价的相等谓词，则行为未定义。
:1318
---
---
operator!
operator!
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator!=(const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>
Return `false` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
若 `x.size() == y.size()` 且对于 `x` 中的每个元素，在 `y` 中均存在一个具有相同键且值相等（使用 `operator==` 比较值类型）的元素，则返回 `false`。
:1330
Notes:;; Behavior is undefined if the two containers don't have equivalent equality predicates.
注意：如果两个容器不具有等价的相等谓词，则行为未定义。
Swap
交换
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> void swap(unordered_node_set<Key, T, Hash, Pred, Alloc>& x, unordered_node_set<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y))); ```
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> void swap(unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>
Swaps the contents of `x` and `y`.
交换 `x` 和 `y` 的内容。
:1342
If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the containers' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.
如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。
Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping.
效果：`x.swap(y)`
抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
:1348
---
---
erase_if
erase_if
```c++ template<class K, class T, class H, class P, class A, class Predicate> typename unordered_node_set<K, T, H, P, A>::size_type erase_if(unordered_node_set<K, T, H, P, A>& c, Predicate pred); ```
```c++ template<class k,="" class="" t,="" h,="" p,="" a,="" predicate=""> typename unordered_node_set<k, t,="" h,="" p,="" a="">::size_type erase_if(unordered_node_set<k, t,="" h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>
Traverses the container `c` and removes all elements for which the supplied predicate returns `true`.
遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。
Returns:;; The number of erased elements. Notes:;; Equivalent to: + + ```c++ auto original_size = c.size(); for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i); } else { ++i; } } return original_size - c.size(); ```
返回：被擦除的元素数量。
注意：等价于：
```c++
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
if (pred(*i)) {
i = c.erase(i);
} else {
++i;
}
}
return original_size - c.size();
```
Serialization
序列化
``unordered_node_set``s can be archived/retrieved by means of link:../../../../../serialization/index.html[Boost.Serialization^] using the API provided by this library. Both regular and XML archives are supported.
`unordered++_++node++_++set` 可通过本组件库提供的 API，借助 link:../../../../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档与 XML 归档两种格式。
Saving an unordered_node_set to an archive
将 `unordered_node_set` 保存到归档中
English Chinese (Simplified Han script) Actions
merge
合并
Class Template unordered_node_set
类模板 unordered_node_set
:idprefix: unordered_node_set_
:idprefix: unordered_node_set_
Set max_load_factor
设置最大负载因子
```c++ iterator find(const key_type& k); const_iterator find(const key_type& k) const; template<class K> iterator find(const K& k);
```c++ iterator find(const key_type&amp; k); const_iterator find(const key_type&amp; k) const; template<class k=""> iterator find(const K&amp; k);</class>
```
```
reset_stats
reset_stats
```c++ void reset_stats() noexcept; ```
```c++ void reset_stats() noexcept; ```
Deduction Guides
推导指引
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator!=(const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>
Return `false` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
若 `x.size() == y.size()` 且对于 `x` 中的每个元素，在 `y` 中均存在一个具有相同键且值相等（使用 `operator==` 比较值类型）的元素，则返回 `false`。
Swaps the contents of `x` and `y`.
交换 `x` 和 `y` 的内容。
Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping.
效果：`x.swap(y)`
抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
erase_if
erase_if
```c++ template<class K, class T, class H, class P, class A, class Predicate> typename unordered_node_set<K, T, H, P, A>::size_type erase_if(unordered_node_set<K, T, H, P, A>& c, Predicate pred); ```
```c++ template<class k,="" class="" t,="" h,="" p,="" a,="" predicate=""> typename unordered_node_set<k, t,="" h,="" p,="" a="">::size_type erase_if(unordered_node_set<k, t,="" h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>
Traverses the container `c` and removes all elements for which the supplied predicate returns `true`.
遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。
Returns:;; The number of erased elements. Notes:;; Equivalent to: + + ```c++ auto original_size = c.size(); for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i); } else { ++i; } } return original_size - c.size(); ```
返回：被擦除的元素数量。
注意：等价于：
```c++
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
if (pred(*i)) {
i = c.erase(i);
} else {
++i;
}
}
return original_size - c.size();
```
Serialization
序列化
Saving an iterator/const_iterator to an archive
将迭代器/常量迭代器保存到归档
Saves the positional information of an `iterator` (`const_iterator`) `it` to an archive (XML archive) `ar`. `it` can be and `end()` iterator.
将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可以是一个 `end()` 迭代器。
Makes an `iterator` (`const_iterator`) `it` point to the restored position of the original `iterator` (`const_iterator`) saved to the storage read by an archive (XML archive) `ar`.
使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML 归档）`ar` 所读取存储中的位置恢复后的位置。
Requires:;; If `x` is the `unordered_node_set` `it` points to, no modifying operations have been issued on `x` between loading of `x` and loading of `it`.
要求：如果 `x` 是 `it` 所指向的 `unordered_node_set` 容器，则在加载 `x` 和加载 `it` 之间，不能对 `x` 执行任何修改操作。
count
count
```c++ size_type count(const key_type& k) const; template<class K> size_type count(const K& k) const; ```
```c++ size_type count(const key_type&amp; k) const; template<class k=""> size_type count(const K&amp; k) const; ```</class>
operator!
operator!
Swap
交换
Saves all the elements of an `unordered_node_set` `x` to an archive (XML archive) `ar`.
将 `unordered_node_set` 容器 `x` 的所有元素保存到归档（XML 归档）`ar` 中。
Requires:;; `value_type` is serializable (XML serializable), and it supports Boost.Serialization `save_construct_data`/`load_construct_data` protocol (automatically suported by https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^] types).
要求：`value_type` 必须是可序列化的（对于 XML 归档需支持 XML 序列化），并且支持 Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协议由满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 的类型自动支持）。
Deletes all preexisting elements of an `unordered_node_set` `x` and inserts from an archive (XML archive) `ar` restored copies of the elements of the original `unordered_node_set` `other` saved to the storage read by `ar`.
删除 `unordered_node_set` 容器 `x` 中所有已存在的元素，并从归档（XML 归档）`ar` 中插入从原始 `unordered_node_set` 容器 `other` 保存到 `ar` 所读取存储中的元素恢复出的副本。
Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. `x.key_equal()` is functionally equivalent to `other.key_equal()`.
要求;; `value++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 要求，且 `x.key++_++equal()` 在功能上需等价于 `other.key++_++equal()` 。

Loading…

User avatar admin

Translation uploaded
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
```c++ template<class Kkey,="" class T, class Hash, class Pred, class A="" t,="" hash,="" pred,="" alloc=""> bool operator!=(const unordered_node_set<Kkey, T, Hash, Pred, Alloc>&t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<Kkey, T, Hash, Pred, Alloc>& y); ```t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>
06/05/2026
User avatar admin

String added in the repository
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_set<Key, T, Hash, Pred, Alloc>& x, const unordered_node_set<Key, T, Hash, Pred, Alloc>& y); ```
06/05/2026
Browse all string changes

Things to check

Consecutive duplicated words

The following word is duplicated: key,><

Reset

Glossary

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

String information

Flags
safe-html, strict-same
Unit identifier
52718
Source string location
:1321
String age
06/05/2026
Last updated
06/06/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/reference/unordered_node_set_zh_Hans.adoc, string 374