":286" = "---";















":327" = "---";



":336" = "---";


":347" = "迭代器类别至少为前向迭代器。";

":351" = "---";

":360" = "迭代器类别至少为前向迭代器。";
":362" = "---";

":372" = "---";


":394" = "---";




":407" = "后置条件：`size() == 0`  \n要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":410" = "---";



":424" = "后置条件：`size() == 0`  \n要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":427" = "---";


":443" = "要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":445" = "---";




":456" = "---";



":468" = "---";



":479" = "要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":481" = "---";



":490" = "---";



":499" = "---";



":513" = "---";




":531" = "---";


":546" = "要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":548" = "---";




":561" = "---";




":574" = "---";


":586" = "要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":588" = "---";


":601" = "要求;; `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。";
":603" = "---";



":614" = "要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":616" = "---";



":627" = "要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":629" = "---";



":641" = "要求：`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。";
":643" = "---";



":654" = "---";




":669" = "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。";
":671" = "---";


":688" = "---";



":698" = "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。";




":712" = "---";



":723" = "---";



":734" = "---";



":744" = "---";




":757" = "---";



":768" = "---";



":779" = "---";



":788" = "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。";
":791" = "要求：`value_type` 可从 `args` 构造。  \n返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  \n如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。  \n\n如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元素为止，仅使用 `k` 参数进行检查。当 `key_type` 可移动构造或 `k` 参数本身就是 `key_type` 类型时，此优化生效。";
":800" = "---";


":807" = "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。";

":812" = "要求：`value_type` 可从 `args` 构造。  \n返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  \n如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。  \n\n如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元素为止，仅使用 `k` 参数进行检查。当 `key_type` 可移动构造或 `k` 参数本身就是 `key_type` 类型时，此优化生效。";
":821" = "---";


":829" = "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。";

":841" = "---";


":849" = "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。";

":861" = "---";


":870" = "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。";

":882" = "---";


":890" = "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。";
":892" = "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。";

":904" = "---";


":911" = "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入这些元素。";

":918" = "---";


":925" = "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入这些元素。";

":932" = "---";








":950" = "---";



":960" = "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。";

":968" = "---";


":980" = "如果容器中不存在键为 `k` 的元素，则插入一个新元素。";
":982" = "如果已存在键为 `k` 的元素，则该函数不执行任何操作。";

":995" = "```c++\nvalue_type(std::piecewise_construct,\n          std::forward_as_tuple(std::forward<key>(k)),\n          std::forward_as_tuple(std::forward<args>(args)...))\n```</args></key>";
":1000" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>";

":1007" = "可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。";
":1009" = "`template<class k,=\"\" args=\"\">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>";
":1011" = "--";
":1013" = "---";


":1025" = "如果容器中不存在键为 `k` 的元素，则插入一个新元素。";
":1027" = "如果已存在键为 `k` 的元素，则该函数不执行任何操作。";


":1040" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>";
":1045" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>";

":1052" = "可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。";
":1054" = "`template<class k,=\"\" args=\"\">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>";
":1056" = "--";
":1058" = "---";


":1070" = "向容器中插入一个新元素，或通过赋值更新现有元素的值。";
":1072" = "如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>";
":1074" = "如果不存在这样的元素，则将其添加到容器中，形式为：  \n```c++";
":1077" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>";
":1082" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>";

":1096" = "---";


":1108" = "向容器中插入一个新元素，或通过赋值更新现有元素的值。";
":1110" = "如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>";
":1112" = "如果不存在这样的元素，则将其添加到容器中，形式为：  \n```c++";
":1115" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>";
":1120" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>";
":1125" = "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。";

":1134" = "---";



":1153" = "---";




":1168" = "---";




":1182" = "---";



":1193" = "如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。";

":1198" = "---";




":1211" = "---";




":1226" = "---";



":1236" = "---";




":1248" = "---";




":1266" = "---";




":1278" = "---";



":1288" = "---";



":1298" = "---";





":1315" = "---";



":1328" = "---";



":1341" = "---";



":1357" = "---";



":1374" = "---";



":1389" = "---";




":1401" = "---";




":1413" = "---";



":1424" = "---";



":1434" = "---";



":1448" = "---";




":1459" = "使迭代器失效并改变元素的顺序。";
":1462" = "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。";
":1464" = "---";




":1475" = "使迭代器失效并改变元素的顺序。";
":1478" = "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。";
":1480" = "---";




":1493" = "---";



":1504" = "---";












":1563" = "注意：如果两个容器不具有等价的相等谓词，则行为未定义。";
":1565" = "---";



":1577" = "注意：如果两个容器不具有等价的相等谓词，则行为未定义。";



":1589" = "如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。";

":1595" = "---";









":1641" = "---";



":1655" = "---";



":1667" = "---";