上传文件至 'src/MyTinySTL-master/MyTinySTL'

我是赵澜博

src/MyTinySTL-master/MyTinySTL/unordered_set.h

@@ -1,14 +1,44 @@
-namespace mystl
+/*这段代码定义了两个模板类 unordered_set 和 unordered_multiset，它们都是基于哈希表（hashtable）实现的关联容器，用于存储键值。以下是这两个类的主要功能和区别：
-{
+
-
+unordered_set 功能
-    // 模板类 unordered_set，用于存储不允许重复的键值。
+存储不允许重复的键值：unordered_set 用于存储唯一的键值，不允许键值重复。
+哈希表底层实现：使用哈希表作为底层数据结构，提供高效的插入、删除和查找操作。
+迭代器支持：提供迭代器和常量迭代器，用于遍历容器中的元素。
+容量操作：可以检查容器是否为空、获取容器的大小和最大容量。
+元素操作：
+插入：通过 emplace 和 insert 方法插入元素，如果元素已存在则不插入。
+删除：通过 erase 方法删除指定元素或范围内的元素。
+清空：通过 clear 方法清空容器中的所有元素。
+查找操作：提供 find 和 equal_range 方法用于查找元素。
+桶操作：提供桶相关的操作，如获取桶的数量、桶的大小和元素所在的桶编号。
+哈希策略：可以获取和设置负载因子、重新哈希和预留空间。
+比较操作：重载了 == 和 != 操作符，用于比较两个 unordered_set 是否相等或不相等。
+unordered_multiset 功能
+存储允许重复的键值：与 unordered_set 不同，unordered_multiset 允许键值重复。
+哈希表底层实现：同样使用哈希表作为底层数据结构，提供高效的插入、删除和查找操作。
+迭代器支持：提供迭代器和常量迭代器，用于遍历容器中的元素。
+容量操作：可以检查容器是否为空、获取容器的大小和最大容量。
+元素操作：
+插入：通过 emplace 和 insert 方法插入元素，允许键值重复。
+删除：通过 erase 方法删除指定元素或范围内的元素。
+清空：通过 clear 方法清空容器中的所有元素。
+查找操作：提供 find 和 equal_range 方法用于查找元素。
+桶操作：提供桶相关的操作，如获取桶的数量、桶的大小和元素所在的桶编号。
+哈希策略：可以获取和设置负载因子、重新哈希和预留空间。
+总结
+unordered_set 适用于需要存储唯一键值的场景，例如存储不重复的标识符或集合。
+unordered_multiset 适用于需要存储允许重复键值的场景，例如统计元素出现的次数或处理多值集合。
+这两个类提供了丰富的操作和灵活的使用方式，是实现高效关联容器的有力工具。*/
+namespace mystl // 定义命名空间 mystl，用于封装自定义的 STL 组件
+{
+    // 模板类 unordered_set，用于存储不允许重复的键值
     // 参数一代表键值类型，参数二代表哈希函数，默认使用 mystl::hash，
     // 参数三代表键值比较方式，默认使用 mystl::equal_to。
     template <class Key, class Hash = mystl::hash<Key>, class KeyEqual = mystl::equal_to<Key>>
     class unordered_set
     {
     private:
-        // 使用 hashtable 作为底层机制来存储数据。
+        // 使用 hashtable 作为底层机制来存储数据
         typedef hashtable<Key, Hash, KeyEqual> base_type;
         base_type ht_;  // 实际存储数据的哈希表对象
 
@@ -19,17 +49,15 @@
         typedef typename base_type::value_type           value_type;      // 值类型
         typedef typename base_type::hasher               hasher;          // 哈希函数类型
         typedef typename base_type::key_equal            key_equal;       // 键值比较函数类型
-
         typedef typename base_type::size_type            size_type;       // 大小类型
         typedef typename base_type::difference_type      difference_type; // 差异类型
         typedef typename base_type::pointer              pointer;         // 指针类型
         typedef typename base_type::const_pointer        const_pointer;   // 常量指针类型
         typedef typename base_type::reference            reference;       // 引用类型
         typedef typename base_type::const_reference      const_reference; // 常量引用类型
-
+        typedef typename base_type::iterator             iterator;        // 迭代器类型
-        typedef typename base_type::const_iterator       iterator;        // 迭代器类型
         typedef typename base_type::const_iterator       const_iterator;  // 常量迭代器类型
-        typedef typename base_type::const_local_iterator local_iterator;  // 本地迭代器类型
+        typedef typename base_type::local_iterator       local_iterator;  // 本地迭代器类型
         typedef typename base_type::const_local_iterator const_local_iterator;  // 常量本地迭代器类型
 
         // 获取分配器
@@ -141,227 +169,265 @@
     // 修改容器操作
 
     // emplace / emplace_hint
-    // emplace 函数用于在容器中直接构造一个新元素，参数是构造函数需要的参数。
+    // emplace 函数用于在容器中直接构造一个新元素，参数是构造函数需要的参数
-    // emplace_hint 函数与 emplace 类似，但提供了一个迭代器 hint 作为插入位置的提示。
+    // emplace_hint 函数与 emplace 类似，但提供了一个迭代器 hint 作为插入位置的提示
     template <class ...Args>
     pair<iterator, bool> emplace(Args&& ...args)
     {
-        // 调用底层哈希表的 emplace_unique 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_unique 函数，尝试插入一个新元素
-        // mystl::forward 用于完美转发参数，保留参数的引用类型。
+        // mystl::forward 用于完美转发参数，保留参数的引用类型
         return ht_.emplace_unique(mystl::forward<Args>(args)...);
     }
 
     template <class ...Args>
     iterator emplace_hint(const_iterator hint, Args&& ...args)
     {
-        // 调用底层哈希表的 emplace_unique_use_hint 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_unique_use_hint 函数，尝试插入一个新元素
-        // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
         return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
     }
 
     // insert
-    // insert 函数用于将一个元素插入容器中，如果元素已存在则不插入。
+    // insert 函数用于将一个元素插入容器中，如果元素已存在则不插入
     pair<iterator, bool> insert(const value_type& value)
     {
-        // 调用底层哈希表的 insert_unique 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 insert_unique 函数，尝试插入一个新元素
         return ht_.insert_unique(value);
     }
 
     pair<iterator, bool> insert(value_type&& value)
     {
-        // 调用底层哈希表的 emplace_unique 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_unique 函数，尝试插入一个新元素
-        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制。
+        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制
         return ht_.emplace_unique(mystl::move(value));
     }
 
     iterator insert(const_iterator hint, const value_type& value)
     {
-        // 调用底层哈希表的 insert_unique_use_hint 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 insert_unique_use_hint 函数，尝试插入一个新元素
-        // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
         return ht_.insert_unique_use_hint(hint, value);
     }
 
     iterator insert(const_iterator hint, value_type&& value)
     {
-        // 调用底层哈希表的 emplace_unique_use_hint 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_unique_use_hint 函数，尝试插入一个新元素
-        // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
-        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制。
+        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制
         return ht_.emplace_unique_use_hint(hint, mystl::move(value));
     }
 
     template <class InputIterator>
     void insert(InputIterator first, InputIterator last)
     {
-        // 调用底层哈希表的 insert_unique 函数，将一个范围内的元素插入容器中。
+        // 调用底层哈希表的 insert_unique 函数，将一个范围内的元素插入容器中
         ht_.insert_unique(first, last);
     }
 
     // erase / clear
-    // erase 函数用于从容器中删除元素。
+    // erase 函数用于从容器中删除元素
     void      erase(iterator it)
     {
-        // 调用底层哈希表的 erase 函数，删除指定位置的元素。
+        ht_.erase(it); // 调用底层哈希表的 erase 函数，删除指定迭代器位置的元素
+    }
+     erase(iterator first, iterator last)
+    {
+        ht_.erase(first, last); // 调用底层哈希表的 erase 函数，删除指定范围的元素
+    }
+
+    // 删除指定键的所有元素，并返回被删除的元素数量
+    size_type erase(const key_type& key)
+    {
+        return ht_.erase_unique(key); // 调用底层哈希表的 erase_unique 函数，删除指定键的所有元素
+    }
+
+    // 清空容器
+    void      clear()
+    {
+        ht_.clear(); // 调用底层哈希表的 clear 函数，清空容器中的所有元素
+    }
+
+ ```cpp
+template <class InputIterator>
+void insert(InputIterator first, InputIterator last)
+{
+    // 将迭代器范围内的元素插入到容器中，利用底层哈希表的插入功能
+    ht_.insert_unique(first, last);
+}
+
+// 删除指定迭代器位置的元素
+void      erase(iterator it)
+{
+    // 调用底层哈希表的 erase 方法，移除指定位置的元素
     ht_.erase(it);
 }
 
+// 删除指定范围内的元素
 void      erase(iterator first, iterator last)
 {
-        // 调用底层哈希表的 erase 函数，删除指定范围内的元素。
+    // 调用底层哈希表的 erase 方法，移除指定范围内的元素
     ht_.erase(first, last);
 }
 
+// 删除所有指定键的元素，并返回删除的元素数量
 size_type erase(const key_type& key)
 {
-        // 调用底层哈希表的 erase_unique 函数，删除指定键值的元素。
+    // 调用底层哈希表的 erase_unique 方法，移除所有指定键的元素
     return ht_.erase_unique(key);
 }
 
+// 清空容器中的所有元素
 void      clear()
 {
-        // 调用底层哈希表的 clear 函数，清空容器中的所有元素。
+    // 调用底层哈希表的 clear 方法，清空容器
     ht_.clear();
 }
 
+// 交换两个 unordered_set 容器的内容
 void      swap(unordered_set& other) noexcept
 {
-        // 调用底层哈希表的 swap 函数，交换两个容器的内容。
+    // 调用底层哈希表的 swap 方法，交换两个容器的内容
     ht_.swap(other.ht_);
 }
 
-    // 查找相关
+// 返回指定键值的元素个数
-    // count 函数用于返回指定键值的元素个数。
 size_type      count(const key_type& key) const
 {
-        // 调用底层哈希表的 count 函数，返回指定键值的元素个数。
+    // 调用底层哈希表的 count 方法，统计指定键值的元素个数
     return ht_.count(key);
 }
 
-    // find 函数用于查找指定键值的元素，并返回指向该元素的迭代器。
+// 查找指定键值的元素，并返回指向该元素的迭代器
 iterator       find(const key_type& key)
 {
-        // 调用底层哈希表的 find 函数，查找指定键值的元素。
+    // 调用底层哈希表的 find 方法，查找指定键值的元素
     return ht_.find(key);
 }
 
+// 查找指定键值的元素，并返回指向该元素的常量迭代器
 const_iterator find(const key_type& key)  const
 {
-        // 调用底层哈希表的 find 函数，查找指定键值的元素。
+    // 调用底层哈希表的 find 方法，查找指定键值的元素
     return ht_.find(key);
 }
 
-    // equal_range 函数用于查找指定键值的元素范围，并返回一个迭代器对。
+// 查找指定键值的元素范围，并返回一个迭代器对
 pair<iterator, iterator> equal_range(const key_type& key)
 {
-        // 调用底层哈希表的 equal_range_unique 函数，查找指定键值的元素范围。
+    // 调用底层哈希表的 equal_range_unique 方法，查找指定键值的元素范围
     return ht_.equal_range_unique(key);
 }
 
+// 查找指定键值的元素范围，并返回一个常量迭代器对
 pair<const_iterator, const_iterator> equal_range(const key_type& key) const
 {
-        // 调用底层哈希表的 equal_range_unique 函数，查找指定键值的元素范围。
+    // 调用底层哈希表的 equal_range_unique 方法，查找指定键值的元素范围
     return ht_.equal_range_unique(key);
 }
 
-    // bucket interface
+// 返回指向指定桶开始的迭代器
-    // begin 函数用于返回指向指定桶的开始的迭代器。
 local_iterator       begin(size_type n)        noexcept
 {
-        // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器。
+    // 调用底层哈希表的 begin 方法，获取指定桶的开始迭代器
     return ht_.begin(n);
 }
 
+// 返回指向指定桶开始的常量迭代器
 const_local_iterator begin(size_type n)  const noexcept
 {
-        // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器。
+    // 调用底层哈希表的 begin 方法，获取指定桶的开始常量迭代器
     return ht_.begin(n);
 }
 
+// 返回指向指定桶开始的常量迭代器
 const_local_iterator cbegin(size_type n) const noexcept
 {
-        // 调用底层哈希表的 cbegin 函数，返回指向指定桶的开始的常量迭代器。
+    // 调用底层哈希表的 cbegin 方法，获取指定桶的开始常量迭代器
     return ht_.cbegin(n);
 }
 
-    // end 函数用于返回指向指定桶的结束的迭代器。
+// 返回指向指定桶结束的迭代器
 local_iterator       end(size_type n)          noexcept
 {
-        // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器。
+    // 调用底层哈希表的 end 方法，获取指定桶的结束迭代器
     return ht_.end(n);
 }
 
+// 返回指向指定桶结束的常量迭代器
 const_local_iterator end(size_type n)    const noexcept
 {
-        // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器。
+    // 调用底层哈希表的 end 方法，获取指定桶的结束常量迭代器
     return ht_.end(n);
 }
 
+// 返回指向指定桶结束的常量迭代器
 const_local_iterator cend(size_type n)   const noexcept
 {
-        // 调用底层哈希表的 cend 函数，返回指向指定桶的结束的常量迭代器。
+    // 调用底层哈希表的 cend 方法，获取指定桶的结束常量迭代器
     return ht_.cend(n);
 }
 
-    // bucket_count 函数用于返回容器中的桶数量。
+// 返回容器中的桶数量
 size_type bucket_count()                 const noexcept
 {
-        // 调用底层哈希表的 bucket_count 函数，返回容器中的桶数量。
+    // 调用底层哈希表的 bucket_count 方法，获取桶的数量
     return ht_.bucket_count();
 }
 
-    // max_bucket_count 函数用于返回容器中允许的最大桶数量。
+// 返回容器中允许的最大桶数量
 size_type max_bucket_count()             const noexcept
 {
-        // 调用底层哈希表的 max_bucket_count 函数，返回容器中允许的最大桶数量。
+    // 调用底层哈希表的 max_bucket_count 方法，获取最大桶数量
     return ht_.max_bucket_count();
 }
 
-    // bucket_size 函数用于返回指定桶中的元素数量。
+// 返回指定桶中的元素数量
 size_type bucket_size(size_type n)       const noexcept
 {
-        // 调用底层哈希表的 bucket_size 函数，返回指定桶中的元素数量。
+    // 调用底层哈希表的 bucket_size 方法，获取指定桶的元素数量
     return ht_.bucket_size(n);
 }
 
-    // bucket 函数用于返回指定键值所在的桶的索引。
+// 返回指定键值所在的桶的索引
 size_type bucket(const key_type& key)    const
 {
-        // 调用底层哈希表的 bucket 函数，返回指定键值所在的桶的索引。
+    // 调用底层哈希表的 bucket 方法，获取键值所在桶的索引
     return ht_.bucket(key);
 }
 
-    // hash policy
+// 返回容器的负载因子，即元素数量与桶数量的比值
-    // load_factor 函数用于返回容器的负载因子，即元素数量与桶数量的比值。
 float     load_factor()            const noexcept { return ht_.load_factor(); }
 
-    // max_load_factor 函数用于获取或设置容器的最大负载因子。
+// 获取或设置容器的最大负载因子
 float     max_load_factor()        const noexcept { return ht_.max_load_factor(); }
 void      max_load_factor(float ml) { ht_.max_load_factor(ml); }
 
-    // rehash 函数用于重新哈希容器，指定新的桶数量。
+// 重新哈希容器，指定新的桶数量
 void      rehash(size_type count) { ht_.rehash(count); }
 
-    // reserve 函数用于预留空间，指定容器需要容纳的元素数量。
+// 预留空间，指定容器需要容纳的元素数量
 void      reserve(size_type count) { ht_.reserve(count); }
 
-    // hash_fcn 函数用于返回容器使用的哈希函数。
+// 返回容器使用的哈希函数
 hasher    hash_fcn()               const { return ht_.hash_fcn(); }
 
-    // key_eq 函数用于返回容器使用的键值比较函数。
+// 返回容器使用的键值比较函数
 key_equal key_eq()                 const { return ht_.key_eq(); }
-
+```
 public:
-    // 重载相等操作符
+    // 重载相等操作符，用于比较两个 unordered_set 容器是否相等
     friend bool operator==(const unordered_set& lhs, const unordered_set& rhs)
     {
-        // 调用底层哈希表的 equal_range_unique 函数，比较两个容器的元素是否相等。
+        // 调用底层哈希表的 equal_range_unique 函数，比较两个容器的元素是否相等
         return lhs.ht_.equal_range_unique(rhs.ht_);
     }
 
-    // 重载不等操作符
+    // 重载不等操作符，用于比较两个 unordered_set 容器是否不相等
     friend bool operator!=(const unordered_set& lhs, const unordered_set& rhs)
     {
-        // 调用底层哈希表的 equal
+        // 利用相等操作符的结果来判断两个容器是否不相等
-
+        return !(lhs == rhs);
+    }
 /*****************************************************************************************/
 // 模板类 unordered_multiset，用于存储允许重复的键值。
 // 参数一代表键值类型，参数二代表哈希函数，默认使用 mystl::hash，
@@ -381,14 +447,12 @@ public:
     typedef typename base_type::value_type           value_type;      // 值类型
     typedef typename base_type::hasher               hasher;          // 哈希函数类型
     typedef typename base_type::key_equal            key_equal;       // 键值比较函数类型
-
     typedef typename base_type::size_type            size_type;       // 大小类型
     typedef typename base_type::difference_type      difference_type; // 差异类型
     typedef typename base_type::pointer              pointer;         // 指针类型
     typedef typename base_type::const_pointer        const_pointer;   // 常量指针类型
     typedef typename base_type::reference            reference;       // 引用类型
     typedef typename base_type::const_reference      const_reference; // 常量引用类型
-
     typedef typename base_type::const_iterator       iterator;        // 迭代器类型
     typedef typename base_type::const_iterator       const_iterator;  // 常量迭代器类型
     typedef typename base_type::const_local_iterator local_iterator;  // 本地迭代器类型
@@ -462,19 +526,18 @@ public:
         ht_ = mystl::move(rhs.ht_);
         return *this;
     }
-
             // 列表赋值运算符
             unordered_multiset& operator=(std::initializer_list<value_type> ilist)
             {
-                ht_.clear();
+                ht_.clear(); //
                 ht_.reserve(ilist.size());
                 for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
                     ht_.insert_multi_noresize(*first);  // 插入元素，不重新分配空间
-                return *this;
+                return *this; //
             }
-
+ //
             // 析构函数
-            ~unordered_multiset() = default;
+        ~unordered_multiset() = default; // 默认析构函数，由编译器自动生成，用于释放资源
 
         // 迭代器相关函数
 
@@ -499,189 +562,189 @@ public:
         // 返回容器可以容纳的最大元素数量
         size_type max_size() const noexcept { return ht_.max_size(); }
     };
+
     // 修改容器相关
 
     // emplace / emplace_hint
-        // emplace 函数用于在容器中直接构造一个新元素，参数是构造函数需要的参数。
+    // emplace 函数用于在容器中直接构造一个新元素，参数是构造函数需要的参数
-        // emplace_hint 函数与 emplace 类似，但提供了一个迭代器 hint 作为插入位置的提示。
+    // emplace_hint 函数与 emplace 类似，但提供了一个迭代器 hint 作为插入位置的提示
     template <class ...Args>
     iterator emplace(Args&& ...args)
     {
-            // 调用底层哈希表的 emplace_multi 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_multi 函数，尝试插入一个新元素
-            // mystl::forward 用于完美转发参数，保留参数的引用类型。
+        // mystl::forward 用于完美转发参数，保留参数的引用类型
         return ht_.emplace_multi(mystl::forward<Args>(args)...);
     }
 
     template <class ...Args>
     iterator emplace_hint(const_iterator hint, Args&& ...args)
     {
-            // 调用底层哈希表的 emplace_multi_use_hint 函数，尝试插入一个新元素。
+        // 调用底层哈希表的 emplace_multi_use_hint 函数，尝试插入一个新元素
-            // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
         return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...);
     }
 
     // insert
-        // insert 函数用于将一个元素插入容器中，允许重复。
+    // insert 函数用于将一个元素插入容器中，允许重复
     iterator insert(const value_type& value)
     {
-            // 调用底层哈希表的 insert_multi 函数，插入一个新元素。
+        // 调用底层哈希表的 insert_multi 函数，插入一个新元素
         return ht_.insert_multi(value);
     }
 
     iterator insert(value_type&& value)
     {
-            // 调用底层哈希表的 emplace_multi 函数，插入一个新元素。
+        // 调用底层哈希表的 emplace_multi 函数，插入一个新元素
-            // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制。
+        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制
         return ht_.emplace_multi(mystl::move(value));
     }
 
     iterator insert(const_iterator hint, const value_type& value)
     {
-            // 调用底层哈希表的 insert_multi_use_hint 函数，插入一个新元素。
+        // 调用底层哈希表的 insert_multi_use_hint 函数，插入一个新元素
-            // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
         return ht_.insert_multi_use_hint(hint, value);
     }
 
     iterator insert(const_iterator hint, value_type&& value)
     {
-            // 调用底层哈希表的 emplace_multi_use_hint 函数，插入一个新元素。
+        // 调用底层哈希表的 emplace_multi_use_hint 函数，插入一个新元素
-            // hint 作为插入位置的提示，可以提高插入效率。
+        // hint 作为插入位置的提示，可以提高插入效率
-            // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制。
+        // mystl::move 用于将右值引用转换为左值引用，避免不必要的复制
         return ht_.emplace_multi_use_hint(hint, mystl::move(value));
     }
 
     template <class InputIterator>
     void     insert(InputIterator first, InputIterator last)
     {
-            // 调用底层哈希表的 insert_multi 函数，将一个范围内的元素插入容器中。
+        // 调用底层哈希表的 insert_multi 函数，将一个范围内的元素插入容器中
         ht_.insert_multi(first, last);
     }
 
     // erase / clear
-        // erase 函数用于从容器中删除元素。
+    // erase 函数用于从容器中删除元素
     void      erase(iterator it)
     {
-            // 调用底层哈希表的 erase 函数，删除指定位置的元素。
+        // 调用底层哈希表的 erase 函数，删除指定位置的元素
         ht_.erase(it);
     }
 
     void      erase(iterator first, iterator last)
     {
-            // 调用底层哈希表的 erase 函数，删除指定范围内的元素。
+        // 调用底层哈希表的 erase 函数，删除指定范围内的元素
         ht_.erase(first, last);
     }
 
     size_type erase(const key_type& key)
     {
-            // 调用底层哈希表的 erase_multi 函数，删除指定键值的所有元素。
+        // 调用底层哈希表的 erase_multi 函数，删除指定键值的所有元素
         return ht_.erase_multi(key);
     }
 
     void      clear()
     {
-            // 调用底层哈希表的 clear 函数，清空容器中的所有元素。
+        // 调用底层哈希表的 clear 函数，清空容器中的所有元素
         ht_.clear();
     }
 
     void      swap(unordered_multiset& other) noexcept
     {
-            // 调用底层哈希表的 swap 函数，交换两个容器的内容。
+        // 调用底层哈希表的 swap 函数，交换两个容器的内容
         ht_.swap(other.ht_);
     }
 
     // 查找相关
-        // count 函数用于返回指定键值的元素个数。
+    // count 函数用于返回指定键值的元素个数
     size_type      count(const key_type& key) const
     {
-            // 调用底层哈希表的 count 函数，返回指定键值的元素个数。
+        // 调用底层哈希表的 count 函数，返回指定键值的元素个数
         return ht_.count(key);
     }
 
-        // find 函数用于查找指定键值的元素，并返回指向该元素的迭代器。
+    // find 函数用于查找指定键值的元素，并返回指向该元素的迭代器
     iterator       find(const key_type& key)
     {
-            // 调用底层哈希表的 find 函数，查找指定键值的元素。
+        // 调用底层哈希表的 find 函数，查找指定键值的元素
         return ht_.find(key);
     }
 
     const_iterator find(const key_type& key)  const
     {
-            // 调用底层哈希表的 find 函数，查找指定键值的元素。
+        // 调用底层哈希表的 find 函数，查找指定键值的元素
         return ht_.find(key);
     }
 
-        // equal_range 函数用于查找指定键值的元素范围，并返回一个迭代器对。
+    // equal_range 函数用于查找指定键值的元素范围，并返回一个迭代器对
     pair<iterator, iterator> equal_range(const key_type& key)
     {
-            // 调用底层哈希表的 equal_range_multi 函数，查找指定键值的元素范围。
+        // 调用底层哈希表的 equal_range_multi 函数，查找指定键值的元素范围
         return ht_.equal_range_multi(key);
     }
 
     pair<const_iterator, const_iterator> equal_range(const key_type& key) const
     {
-            // 调用底层哈希表的 equal_range_multi 函数，查找指定键值的元素范围。
+        // 调用底层哈希表的 equal_range_multi 函数，查找指定键值的元素范围
         return ht_.equal_range_multi(key);
     }
 
     // bucket interface
-        // begin 函数用于返回指向指定桶的开始的迭代器。
+    // begin 函数用于返回指向指定桶的开始的迭代器
     local_iterator       begin(size_type n)        noexcept
     {
-            // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器。
+        // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器
         return ht_.begin(n);
     }
 
     const_local_iterator begin(size_type n)  const noexcept
     {
-            // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器。
+        // 调用底层哈希表的 begin 函数，返回指向指定桶的开始的迭代器
         return ht_.begin(n);
     }
 
     const_local_iterator cbegin(size_type n) const noexcept
     {
-            // 调用底层哈希表的 cbegin 函数，返回指向指定桶的开始的常量迭代器。
+        // 调用底层哈希表的 cbegin 函数，返回指向指定桶的开始的常量迭代器
         return ht_.cbegin(n);
     }
 
-        // end 函数用于返回指向指定桶的结束的迭代器。
+    // end 函数用于返回指向指定桶的结束的迭代器
     local_iterator       end(size_type n)          noexcept
     {
-            // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器。
+        // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器
         return ht_.end(n);
     }
 
     const_local_iterator end(size_type n)    const noexcept
     {
-            // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器。
+        // 调用底层哈希表的 end 函数，返回指向指定桶的结束的迭代器
         return ht_.end(n);
     }
 
     const_local_iterator cend(size_type n)   const noexcept
     {
-            // 调用底层哈希表的 cend 函数，返回指向指定桶的结束的常量迭代器。
+        // 调用底层哈希表的 cend 函数，返回指向指定桶的结束的常量迭代器
         return ht_.cend(n);
     }
 
-        // bucket_count 函数用于返回容器中的桶数量。
+    // bucket_count 函数用于返回容器中的桶数量
     size_type bucket_count()                 const noexcept
     {
-            // 调用底层哈希表的 bucket_count 函数，返回容器中的桶数量。
+        // 调用底层哈希表的 bucket_count 函数，返回容器中的桶数量
         return ht_.bucket_count();
     }
-
         // max_bucket_count 函数用于返回容器中允许的最大桶数量。
         size_type max_bucket_count()             const noexcept
         {
             // 调用底层哈希表的 max_bucket_count 函数，返回容器中允许的最大桶数量。
-            return ht_.max_bucket_count();
+            return ht_.max_bucket_count(); //
         }
 
-        // bucket_size 函数用于返回指定桶中的元素数量。
+        // bucket_size 函数用于返回指定桶中的元素数量。 //
         size_type bucket_size(size_type n)       const noexcept
-        {
+        { //
             // 调用底层哈希表的 bucket_size 函数，返回指定桶中的元素数量。
             return ht_.bucket_size(n);
         }
-
+ //
         // bucket 函数用于返回指定键值所在的桶的索引。
-        size_type bucket(const ke
+        size_type bucket(const ke //