":280" = "---";




















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

":331" = "---";

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


":353" = "---";


":364" = "---";

":374" = "---";


":396" = "---";




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



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


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




":461" = "要求：`value_type` 可拷贝构造。";
":463" = "---";




":476" = "---";



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



":498" = "---";



":507" = "---";




":520" = "---";


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




":550" = "---";




":563" = "---";


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


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



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



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



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



":643" = "---";





":658" = "要求：`value_type` 可拷贝构造。";
":660" = "---";




":676" = "---";





":690" = "begin";


":699" = "---";
":701" = "end";


":710" = "---";
":712" = "cbegin";


":720" = "---";
":722" = "cend";


":730" = "---";




":743" = "---";



":754" = "---";



":765" = "---";



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

":788" = "---";


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


":811" = "---";


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

":830" = "---";


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

":849" = "---";



":858" = "仅当 std::is_constructible<value_type, p&&=\"\">::value 为 true 时参与重载决议。</value_type,>";

":865" = "---";


":873" = "`hint` 是关于元素插入位置的建议。";

":885" = "---";


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

":906" = "---";



":916" = "仅当 `std::is_constructible<value_type, p&&=\"\">::value` 为 `true` 时参与重载决议。</value_type,>";
":918" = "`hint` 是关于元素插入位置的建议。";

":928" = "---";


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

":944" = "---";


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

":960" = "---";


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

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

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


":1017" = "如果容器中不存在键为 `k` 的元素，则插入一个新元素。";
":1019" = "如果已存在键为 `k` 的元素，则该函数不执行任何操作。";
":1021" = "`hint` 是关于元素插入位置的建议。";

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


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


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

":1092" = "---";


":1104" = "向容器中插入一个新元素，或通过赋值更新现有元素的值。";
":1106" = "如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>";
":1108" = "向容器中插入新元素，或通过赋值给已存在的元素值来更新该元素。";
":1111" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>";
":1116" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>";
":1121" = "`hint` 是关于元素插入位置的建议。";

":1134" = "---";




":1147" = "---";




":1164" = "---";


":1171" = "如果 `nh` 为空，则无效果。";
":1173" = "否则，当且仅当容器中没有具有等价键的元素时，才插入 `nh` 所拥有的元素。";

":1189" = "---";


":1196" = "如果 `nh` 为空，则无效果。";
":1198" = "否则，当且仅当容器中没有具有等价键的元素时，才插入 `nh` 所拥有的元素。";

":1202" = "`hint` 是关于元素插入位置的建议。";

":1220" = "---";


":1229" = "擦除 `position` 所指向的元素。";

":1236" = "---";




":1251" = "---";




":1267" = "---";


":1274" = "擦除 `position` 所指向的元素。";
":1277" = "抛出：;; 仅当由 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。\n\n在此实现中，此重载不会调用任一函数对象的方法，因此不会抛出异常，但在其他实现中可能并非如此。\n\n备注：;; 之所以实现此方法，是因为从 `erase` 返回下一个元素的迭代器开销较大，但容器已经过重新设计，情况不再如此。因此，此方法现已废弃。";
":1282" = "---";


":1289" = "删除 `position` 所指向的元素。";
":1292" = "抛出：;; 仅当由 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。\n在此实现中，此重载不会调用任一函数对象的方法，因此不会抛出异常，但在其他实现中可能并非如此。\n备注：;; 之所以实现此方法，是因为从 `erase` 返回下一个元素的迭代器开销较大，但容器已经过重新设计，情况不再如此。因此，此方法现已废弃。";
":1297" = "---";



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

":1315" = "---";




":1328" = "---";












":1363" = "---";



":1372" = "---";



":1382" = "---";



":1392" = "---";





":1419" = "---";



":1432" = "---";



":1445" = "---";



":1461" = "---";



":1480" = "---";



":1495" = "---";




":1507" = "---";



":1517" = "---";



":1528" = "---";



":1541" = "---";
":1543" = "begin";


":1554" = "---";
":1556" = "end";


":1566" = "---";
":1568" = "cbegin";


":1577" = "---";
":1579" = "cend";


":1588" = "---";




":1600" = "---";



":1611" = "---";



":1621" = "---";




":1633" = "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。";
":1636" = "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。";
":1638" = "---";




":1649" = "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。";
":1652" = "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。";












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



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



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

":1744" = "---";









":1790" = "---";



":1806" = "---";



":1818" = "---";