Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Concurrent Node Map (adoc) — Chinese (Simplified Han script) @ Boost-Weblate: Inserts an element constructed from `k` and `args` into the …

Zen

Translation

English

Chinese (Simplified Han script)

Needs editing

Skip

Key	English	Chinese (Simplified Han script)
	The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	仅当 Hash::is_transparent 与 Pred::is_transparent 为合法的成员类型别名时，template<class k,="" args=""> 这个重载版本才会参与重载决议。库实现假定 Hash 可同时接受 K 类型与 Key 类型作为参数，且 Pred 是透明的。这一特性支持异构查找，从而避免实例化 Key 类型对象带来的性能开销。</class>
:1368	--	--
:1370	---	---
	try_emplace_or_[c]visit	try_emplace_or_[c]visit
	```c++ template<class... Args, class F> bool try_emplace_or_visit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_visit(key_type&& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(key_type&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_visit(K&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_cvisit(K&& k, Args&&... args, F&& f); ```	```c++ template<class... args,="" class="" f=""> bool try_emplace_or_visit(const key_type& k, Args&&... args, F&& f); template<class... args,="" class="" f=""> bool try_emplace_or_cvisit(const key_type& k, Args&&... args, F&& f); template<class... args,="" class="" f=""> bool try_emplace_or_visit(key_type&& k, Args&&... args, F&& f); template<class... args,="" class="" f=""> bool try_emplace_or_cvisit(key_type&& k, Args&&... args, F&& f); template<class k,="" class...="" args,="" class="" f=""> bool try_emplace_or_visit(K&& k, Args&&... args, F&& f); template<class k,="" class...="" args,="" class="" f=""> bool try_emplace_or_cvisit(K&& k, Args&&... args, F&& f); ```</class></class></class...></class...></class...></class...>
	Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it. Otherwise, invokes `f` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.	若表中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入表中。否则，以指向等价元素的引用调用`f`；当且仅当使用`*_cvisit`重载版本时，该引用为常量引用。
:1392	Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++	返回值：;; 若执行插入操作则返回 true。并发特性：;; 阻塞对 *this 的重哈希操作。注意：;; 若已存在等价键的元素，则不会构造 value_type；否则，构造方式如下：
:1400	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>
:1405	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>
	The interface is exposition only, as C++ does not allow to declare a parameter `f` after a variadic parameter pack.	该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明参数 `f`。
	The `template<class K, class\... Args, class F>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k,="" args,="" class="" f="">` 这些重载版本才会参与重载决议。库假定 `Hash` 可同时接受 `K` 类型和 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
:1414	--	--
:1416	---	---
	try_emplace_and_[c]visit	try_emplace_and_[c]visit
	```c++ template<class... Args, class F1, class F2> bool try_emplace_and_visit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_visit(K&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```	```c++ template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(K&& k, Args&&... args, F1&& f1, F2&& f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```</class></class></class...></class...></class...></class...>
	Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.	若表中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入表中，随后以非常量引用指向新创建的元素并调用`f1`。否则，以指向等价元素的引用调用`f2`；当且仅当使用`*_cvisit`重载版本时，该引用为常量引用。
:1439	Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++	返回值：;; 若执行插入操作则返回 true。并发特性：;; 阻塞对 *this 的重哈希操作。注意：;; 若已存在等价键的元素，则不会构造 value_type；否则，构造方式如下：
:1447	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>
:1452	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>
	The interface is exposition only, as C++ does not allow to declare parameter `f1` and `f2` after a variadic parameter pack.	该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` 和 `f2` 参数。
	The `template<class K, class\... Args, class F1, class F2>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别名时，`template<class k,="" args,="" class="" f1,="" f2="">` 这些重载版本才会参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
:1461	--	--
:1463	---	---
	insert_or_assign	insert_or_assign
	```c++ template<class M> bool insert_or_assign(const key_type& k, M&& obj); template<class M> bool insert_or_assign(key_type&& k, M&& obj); template<class K, class M> bool insert_or_assign(K&& k, M&& obj); ```	```c++ template<class m=""> bool insert_or_assign(const key_type& k, M&& obj); template<class m=""> bool insert_or_assign(key_type&& k, M&& obj); template<class k,="" class="" m=""> bool insert_or_assign(K&& k, M&& obj); ```</class></class></class>
	Inserts a new element into the table or updates an existing one by assigning to the contained value.	向表中插入新元素，或通过为已包含的值赋值来更新现有元素。
	If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.	若表中存在键为`k`的元素，则通过`std::forward<m>(obj)`赋值来更新该元素。</m>
	If there is no such element, it is added to the table as: ```c++	若不存在该元素，则以如下形式添加到表中：
	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>
	Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	返回值：;; 若执行插入操作则返回 `true`。并发特性：;; 阻塞对 `*this` 的重哈希操作。注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k,="" class="" m="">` 才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>

	English	Chinese (Simplified Han script)	Actions
	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; In a call of the form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `value_type&&` argument participate in overload resolution only if `std::remove_reference<decltype(obj)>::type` is `value_type`.	要求：;; `value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^] 要求。返回值：;; 若执行插入操作则返回 `true`。并发特性：;; 阻塞对 `*this` 的重哈希操作。注意：;; 在形式为 `insert_and_[c]visit(obj, f1, f2)` 的调用中，仅当 `std::remove_reference<decltype(obj)>::type` 为 `value_type` 时，接受 `value_type&&` 参数的重载版本才会参与重载决议。</decltype(obj)>
	Insert Iterator Range and Visit	迭代器范围插入并访问
	```c++ template<class InputIterator, class F1, class F2> size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class InputIterator, class F1, class F2> size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f2, F2 f2); ```	```c++ template<class inputiterator,="" class="" f1,="" f2=""> size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class inputiterator,="" class="" f1,="" f2=""> size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f2, F2 f2); ```</class></class>
	Insert Initializer List and Visit	初始化列表插入并访问
	```c++ template<class F1, class F2> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class F1, class F2> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```	```c++ template<class f1,="" class="" f2=""> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class f1,="" class="" f2=""> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```</value_type></class></value_type></class>
	Insert Node and Visit	节点插入并访问
	```c++ template<class F1, class F2> insert_return_type insert_and_visit(node_type&& nh, F1 f1, F2 f2); template<class F1, class F2> insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```	```c++ template<class f1,="" class="" f2=""> insert_return_type insert_and_visit(node_type&& nh, F1 f1, F2 f2); template<class f1,="" class="" f2=""> insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```</class></class>
	If `nh` is empty, does nothing. Otherwise, inserts the associated element in the table if and only if there is no element in the table with a key equivalent to `nh.key()`, and then invokes `f1` with a non-const reference to the newly inserted element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff `insert_or_cvisit` is used.	若`nh`为空，则不执行任何操作。否则，当且仅当哈希表中不存在与`nh.key()`等价的键时，将关联元素插入表中，随后以非常量引用指向新插入的元素并调用`f1`。若存在等价键，则调用`f2`并传入等价元素的引用；当且仅当使用`insert_or_cvisit`时，该引用为常量引用。
	Throws:;; If an exception is thrown by an operation other than a call to `hasher` or call to `f1` or `f2`, the function has no effect. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is not empty and the allocators of `nh` and the container are not equal.	若 `nh` 为空，则不执行任何操作。否则，当且仅当容器中不存在键等价于 `nh.key()` 的元素时，插入关联元素，并以新插入元素的非常量引用为参数调用 `f1` ；否则，以等价元素的引用为参数调用 `f2` ；当且仅当使用 `insert++_++or++_++cvisit` （此处应为 `insert++_++and++_++cvisit` ，可能是英文出了点错误）时该引用为常量引用。
	unlike xref:#concurrent_node_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor.	与 xref:#concurrent_node_map_emplace[emplace] 不同，该函数会直接将所有参数转发给 `value_type` 的构造函数。
	try_emplace_or_[c]visit	try_emplace_or_[c]visit
	The interface is exposition only, as C++ does not allow to declare a parameter `f` after a variadic parameter pack.	该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明参数 `f`。
	The `template<class K, class\... Args, class F>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k,="" args,="" class="" f="">` 这些重载版本才会参与重载决议。库假定 `Hash` 可同时接受 `K` 类型和 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
	try_emplace_and_[c]visit	try_emplace_and_[c]visit
	```c++ template<class... Args, class F1, class F2> bool try_emplace_and_visit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_visit(K&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```	```c++ template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(K&& k, Args&&... args, F1&& f1, F2&& f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```</class></class></class...></class...></class...></class...>
	Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.	若表中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入表中，随后以非常量引用指向新创建的元素并调用`f1`。否则，以指向等价元素的引用调用`f2`；当且仅当使用`*_cvisit`重载版本时，该引用为常量引用。
	The interface is exposition only, as C++ does not allow to declare parameter `f1` and `f2` after a variadic parameter pack.	该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` 和 `f2` 参数。
	The `template<class K, class\... Args, class F1, class F2>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别名时，`template<class k,="" args,="" class="" f1,="" f2="">` 这些重载版本才会参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
	insert_or_assign	insert_or_assign
	```c++ template<class M> bool insert_or_assign(const key_type& k, M&& obj); template<class M> bool insert_or_assign(key_type&& k, M&& obj); template<class K, class M> bool insert_or_assign(K&& k, M&& obj); ```	```c++ template<class m=""> bool insert_or_assign(const key_type& k, M&& obj); template<class m=""> bool insert_or_assign(key_type&& k, M&& obj); template<class k,="" class="" m=""> bool insert_or_assign(K&& k, M&& obj); ```</class></class></class>
	Inserts a new element into the table or updates an existing one by assigning to the contained value.	向表中插入新元素，或通过为已包含的值赋值来更新现有元素。
	If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.	若表中存在键为`k`的元素，则通过`std::forward<m>(obj)`赋值来更新该元素。</m>
	If there is no such element, it is added to the table as: ```c++	若不存在该元素，则以如下形式添加到表中：
	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))	value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
	Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	返回值：;; 若执行插入操作则返回 `true`。并发特性：;; 阻塞对 `*this` 的重哈希操作。注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k,="" class="" m="">` 才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
	erase	擦除
	```c++ size_type erase(const key_type& k); template<class K> size_type erase(const K& k); ```	```c++ size_type erase(const key_type& k); template<class k=""> size_type erase(const K& k); ```</class>
	Erases the element with key equivalent to `k` if it exists.	若存在键与 `k` 等价的元素，则删除该元素。
	Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.	返回值：;; 删除的元素数量（0 或 1）。抛出异常：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
	erase_if by Key	erase_if by Key

Loading…

admin

Translation uploaded

English

Chinese (Simplified Han script) 310 characters editedCurrent translationState: Translated

Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.若表中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入表中，随后以非常量引用指向新创建的元素并调用`f1`。
否则，以指向等价元素的引用调用`f2`；当且仅当使用`*_cvisit`重载版本时，该引用为常量引用。

06/05/2026

admin

String added in the repository

English

Chinese (Simplified Han script) 337 characters editedPrevious translationState: Needs editing (Needs rewriting)

06/05/2026

Browse all string changes

Things to check

Mismatching line breaks

Number of new lines in translation does not match source.

Reset

Glossary

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

String information

Flags

safe-html, strict-same

Unit identifier

52090

Source string location

:1434

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/concurrent_node_map_zh_Hans.adoc, string 338

Shortcut	Action
`?`	Open available keyboard shortcuts.
`Alt` + `Home`	Navigate to the first translation in the current search.
`Alt` + `End`	Navigate to the last translation in the current search.
`Alt` + `PageUp` or `Ctrl` + `↑` or `Alt` + `↑` or `Cmd` + `↑` or	Navigate to the previous translation in the current search.
`Alt` + `PageDown` or `Ctrl` + `↓` or `Alt` + `↓` or `Cmd` + `↓` or	Navigate to the next translation in the current search.
`Ctrl` + `Enter` or `Cmd` + `Enter`	Submit current form; this works the same as pressing Save and continue while editing translation.
`Ctrl` + `Shift` + `Enter` or `Cmd` + `Shift` +`Enter`	Unmark translation as Needing edit and submit it.
`Alt` + `Enter` or `Option` + `Enter`	Submit the string as a suggestion; this works the same as pressing Suggest while editing translation.
`Ctrl` + `E` or `Cmd` + `E`	Focus on translation editor.
`Ctrl` + `U` or `Cmd` + `U`	Focus on comment editor.
`Ctrl` + `M` or `Cmd` + `M`	Shows Automatic suggestions tab.
`Ctrl` + `1` to `Ctrl` + `9` or `Cmd` + `1` to `Cmd` + `9`	Copies placeable of a given number from source string.
`Ctrl` + `M` followed by `1` to `9` or `Cmd` + `M` followed by `1` to `9`	Copy the machine translation of a given number to current translation.
`Ctrl` + `I` followed by `1` to `9` or `Cmd` + `I` followed by `1` to `9`	Ignore one item in the list of failing checks.
`Ctrl` + `J` or `Cmd` + `J`	Shows the Nearby strings tab.
`Ctrl` + `S` or `Cmd` + `S`	Focus on search field.
`Ctrl` + `O` or `Cmd` + `O`	Copy the source string.
`Ctrl` + `Y` or `Cmd` + `Y`	Toggle the Needs editing checkbox.
`→`	Browse the next translation string.
`←`	Browse the previous translation string.

Translation

Things to check

Mismatching line breaks

Glossary

String information

Flags

Details

Unit identifier

Source string location

String age

Last updated

Source string age

Translation file AsciiDoc file