update vector.h util.h unordered_ste.h

MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h

@@ -144,44 +144,94 @@ public:
   // empalce / empalce_hint
 
   template <class ...Args>
-  pair<iterator, bool> emplace(Args&& ...args)
-  { return ht_.emplace_unique(mystl::forward<Args>(args)...); }
+pair<iterator, bool> emplace(Args&& ...args)
+{
+  // 使用哈希表的 emplace_unique 方法插入元素
+  return ht_.emplace_unique(mystl::forward<Args>(args)...);
+}
 
-  template <class ...Args>
-  iterator emplace_hint(const_iterator hint, Args&& ...args)
-  { return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); }
+// 就地构造并插入一个新的元素，使用 hint 提示位置
+template <class ...Args>
+iterator emplace_hint(const_iterator hint, Args&& ...args)
+{
+  // 使用哈希表的 emplace_unique_use_hint 方法插入元素
+  return ht_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...);
+}
 
-  // insert
+// 插入元素
 
-  pair<iterator, bool> insert(const value_type& value)
-  { return ht_.insert_unique(value); }
-  pair<iterator, bool> insert(value_type&& value)
-  { return ht_.emplace_unique(mystl::move(value)); }
+// 插入一个值等于 value 的元素
+pair<iterator, bool> insert(const value_type& value)
+{
+  // 使用哈希表的 insert_unique 方法插入元素
+  return ht_.insert_unique(value);
+}
 
-  iterator insert(const_iterator hint, const value_type& value)
-  { return ht_.insert_unique_use_hint(hint, value); }
-  iterator insert(const_iterator hint, value_type&& value)
-  { return ht_.emplace_unique_use_hint(hint, mystl::move(value)); }
+// 插入一个值等于 value 的右值引用元素
+pair<iterator, bool> insert(value_type&& value)
+{
+  // 使用哈希表的 emplace_unique 方法插入元素
+  return ht_.emplace_unique(mystl::move(value));
+}
 
-  template <class InputIterator>
-  void insert(InputIterator first, InputIterator last)
-  { ht_.insert_unique(first, last); }
+// 在 hint 提示位置插入一个值等于 value 的元素
+iterator insert(const_iterator hint, const value_type& value)
+{
+  // 使用哈希表的 insert_unique_use_hint 方法插入元素
+  return ht_.insert_unique_use_hint(hint, value);
+}
 
-  // erase / clear
+// 在 hint 提示位置插入一个值等于 value 的右值引用元素
+iterator insert(const_iterator hint, value_type&& value)
+{
+  // 使用哈希表的 emplace_unique_use_hint 方法插入元素
+  return ht_.emplace_unique_use_hint(hint, mystl::move(value));
+}
 
-  void      erase(iterator it)
-  { ht_.erase(it); }
-  void      erase(iterator first, iterator last)
-  { ht_.erase(first, last); }
+// 插入一个范围的元素
+template <class InputIterator>
+void insert(InputIterator first, InputIterator last)
+{
+  // 使用哈希表的 insert_unique 方法插入元素
+  ht_.insert_unique(first, last);
+}
 
-  size_type erase(const key_type& key)
-  { return ht_.erase_unique(key); }
+// 删除和清除元素
 
-  void      clear()
-  { ht_.clear(); }
+// 删除一个迭代器指向的元素
+void erase(iterator it)
+{
+  // 使用哈希表的 erase 方法删除元素
+  ht_.erase(it);
+}
+
+// 删除一个迭代器范围的元素
+void erase(iterator first, iterator last)
+{
+  // 使用哈希表的 erase 方法删除元素
+  ht_.erase(first, last);
+}
+
+// 删除一个键值等于 key 的元素
+size_type erase(const key_type& key)
+{
+  // 使用哈希表的 erase_unique 方法删除元素
+  return ht_.erase_unique(key);
+}
+
+// 清除所有元素
+void clear()
+{
+  // 使用哈希表的 clear 方法清除所有元素
+  ht_.clear();
+}
 
-  void      swap(unordered_set& other) noexcept
-  { ht_.swap(other.ht_); }
+// 交换当前 unordered_set 对象与另一个 unordered_set 对象的内容
+void swap(unordered_set& other) noexcept
+{
+  // 使用哈希表的 swap 方法交换内容
+  ht_.swap(other.ht_);
+}
 
   // 查找相关
 
@@ -310,69 +360,83 @@ public:
 public:
   // 构造、复制、移动函数
 
-  unordered_multiset()
+// 默认构造函数，创建一个包含默认数量桶（100）的 unordered_multiset
+unordered_multiset()
     :ht_(100, Hash(), KeyEqual())
-  {
-  }
+{
+}
 
-  explicit unordered_multiset(size_type bucket_count,
+// 显式构造函数，创建一个包含指定数量桶的 unordered_multiset，可能还会指定哈希函数和键值比较函数
+explicit unordered_multiset(size_type bucket_count,
                               const Hash& hash = Hash(),
                               const KeyEqual& equal = KeyEqual())
     :ht_(bucket_count, hash, equal)
-  {
-  }
+{
+}
 
-  template <class InputIterator>
-  unordered_multiset(InputIterator first, InputIterator last,
+// 模板构造函数，创建一个包含指定范围元素的 unordered_multiset，可能还会指定桶的数量和哈希函数和键值比较函数
+template <class InputIterator>
+unordered_multiset(InputIterator first, InputIterator last,
                      const size_type bucket_count = 100,
                      const Hash& hash = Hash(),
                      const KeyEqual& equal = KeyEqual())
     : ht_(mystl::max(bucket_count, static_cast<size_type>(mystl::distance(first, last))), hash, equal)
-  {
-    for (; first != last; ++first)
-      ht_.insert_multi_noresize(*first);
-  }
+{
+  // 将范围 [first, last) 中的元素插入到哈希表中
+  for (; first != last; ++first)
+    ht_.insert_multi_noresize(*first);
+}
 
-  unordered_multiset(std::initializer_list<value_type> ilist,
+// 构造函数，创建一个包含 initializer_list 中元素的 unordered_multiset，可能还会指定桶的数量和哈希函数和键值比较函数
+unordered_multiset(std::initializer_list<value_type> ilist,
                      const size_type bucket_count = 100,
                      const Hash& hash = Hash(),
                      const KeyEqual& equal = KeyEqual())
     :ht_(mystl::max(bucket_count, static_cast<size_type>(ilist.size())), hash, equal)
-  {
-    for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
-      ht_.insert_multi_noresize(*first);
-  }
+{
+  // 将 initializer_list 中的元素插入到哈希表中
+  for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
+    ht_.insert_multi_noresize(*first);
+}
 
-  unordered_multiset(const unordered_multiset& rhs)
+// 拷贝构造函数，创建一个与 rhs 相等的 unordered_multiset
+unordered_multiset(const unordered_multiset& rhs)
     :ht_(rhs.ht_)
-  {
-  }
-  unordered_multiset(unordered_multiset&& rhs) noexcept
+{
+}
+
+// 移动构造函数，创建一个与 rhs 相等的 unordered_multiset，使用移动语义
+unordered_multiset(unordered_multiset&& rhs) noexcept
     : ht_(mystl::move(rhs.ht_))
-  {
-  }
+{
+}
 
-  unordered_multiset& operator=(const unordered_multiset& rhs)
-  {
-    ht_ = rhs.ht_;
-    return *this;
-  }
-  unordered_multiset& operator=(unordered_multiset&& rhs)
-  {
-    ht_ = mystl::move(rhs.ht_);
-    return *this;
-  }
+// 拷贝赋值运算符，将 rhs 的内容赋值给当前 unordered_multiset
+unordered_multiset& operator=(const unordered_multiset& rhs)
+{
+  ht_ = rhs.ht_;
+  return *this;
+}
 
-  unordered_multiset& operator=(std::initializer_list<value_type> ilist)
-  {
-    ht_.clear();
-    ht_.reserve(ilist.size());
-    for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
-      ht_.insert_multi_noresize(*first);
-    return *this;
-  }
+// 移动赋值运算符，将 rhs 的内容移动到当前 unordered_multiset
+unordered_multiset& operator=(unordered_multiset&& rhs)
+{
+  ht_ = mystl::move(rhs.ht_);
+  return *this;
+}
 
-  ~unordered_multiset() = default;
+// 赋值运算符，将 initializer_list 中的元素赋值给当前 unordered_multiset
+unordered_multiset& operator=(std::initializer_list<value_type> ilist)
+{
+  ht_.clear();
+  ht_.reserve(ilist.size());
+  for (auto first = ilist.begin(), last = ilist.end(); first != last; ++first)
+    ht_.insert_multi_noresize(*first);
+  return *this;
+}
+
+// 析构函数，使用默认实现
+~unordered_multiset() = default;
 
 
   // 迭代器相关
@@ -402,44 +466,94 @@ public:
   // emplace / emplace_hint
 
   template <class ...Args>
-  iterator emplace(Args&& ...args)
-  { return ht_.emplace_multi(mystl::forward<Args>(args)...); }
+iterator emplace(Args&& ...args)
+{
+  // 使用哈希表的 emplace_multi 方法插入元素
+  return ht_.emplace_multi(mystl::forward<Args>(args)...);
+}
 
-  template <class ...Args>
-  iterator emplace_hint(const_iterator hint, Args&& ...args)
-  { return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); }
+// 就地构造并插入一个新的元素，使用 hint 提示位置
+template <class ...Args>
+iterator emplace_hint(const_iterator hint, Args&& ...args)
+{
+  // 使用哈希表的 emplace_multi_use_hint 方法插入元素
+  return ht_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...);
+}
 
-  // insert
+// 插入元素
 
-  iterator insert(const value_type& value)
-  { return ht_.insert_multi(value); }
-  iterator insert(value_type&& value)
-  { return ht_.emplace_multi(mystl::move(value)); }
+// 插入一个值等于 value 的元素
+iterator insert(const value_type& value)
+{
+  // 使用哈希表的 insert_multi 方法插入元素
+  return ht_.insert_multi(value);
+}
 
-  iterator insert(const_iterator hint, const value_type& value)
-  { return ht_.insert_multi_use_hint(hint, value); }
-  iterator insert(const_iterator hint, value_type&& value)
-  { return ht_.emplace_multi_use_hint(hint, mystl::move(value)); }
+// 插入一个值等于 value 的右值引用元素
+iterator insert(value_type&& value)
+{
+  // 使用哈希表的 emplace_multi 方法插入元素
+  return ht_.emplace_multi(mystl::move(value));
+}
 
-  template <class InputIterator>
-  void     insert(InputIterator first, InputIterator last)
-  { ht_.insert_multi(first, last); }
+// 在 hint 提示位置插入一个值等于 value 的元素
+iterator insert(const_iterator hint, const value_type& value)
+{
+  // 使用哈希表的 insert_multi_use_hint 方法插入元素
+  return ht_.insert_multi_use_hint(hint, value);
+}
+
+// 在 hint 提示位置插入一个值等于 value 的右值引用元素
+iterator insert(const_iterator hint, value_type&& value)
+{
+  // 使用哈希表的 emplace_multi_use_hint 方法插入元素
+  return ht_.emplace_multi_use_hint(hint, mystl::move(value));
+}
+
+// 插入一个范围的元素
+template <class InputIterator>
+void insert(InputIterator first, InputIterator last)
+{
+  // 使用哈希表的 insert_multi 方法插入元素
+  ht_.insert_multi(first, last);
+}
 
-  // erase / clear
+// 删除和清除元素
 
-  void      erase(iterator it)
-  { ht_.erase(it); }
-  void      erase(iterator first, iterator last)
-  { ht_.erase(first, last); }
+// 删除一个迭代器指向的元素
+void erase(iterator it)
+{
+  // 使用哈希表的 erase 方法删除元素
+  ht_.erase(it);
+}
 
-  size_type erase(const key_type& key)
-  { return ht_.erase_multi(key); }
+// 删除一个迭代器范围的元素
+void erase(iterator first, iterator last)
+{
+  // 使用哈希表的 erase 方法删除元素
+  ht_.erase(first, last);
+}
 
-  void      clear()
-  { ht_.clear(); }
+// 删除一个键值等于 key 的元素
+size_type erase(const key_type& key)
+{
+  // 使用哈希表的 erase_multi 方法删除元素
+  return ht_.erase_multi(key);
+}
+
+// 清除所有元素
+void clear()
+{
+  // 使用哈希表的 clear 方法清除所有元素
+  ht_.clear();
+}
 
-  void      swap(unordered_multiset& other) noexcept 
-  { ht_.swap(other.ht_); }
+// 交换当前 unordered_multiset 对象与另一个 unordered_multiset 对象的内容
+void swap(unordered_multiset& other) noexcept
+{
+  // 使用哈希表的 swap 方法交换内容
+  ht_.swap(other.ht_);
+}
 
   // 查找相关
 

MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h

@@ -21,173 +21,195 @@ typename std::remove_reference<T>::type&& move(T&& arg) noexcept
 // forward
 
 template <class T>
-T&& forward(typename std::remove_reference<T>::type& arg) noexcept
+T&& forward(typename std::remove_reference<T>::type& arg) noexcept // noexcept 表示函数不会抛出异常
 {
-  return static_cast<T&&>(arg);
+    // 使用 static_cast 将左值引用转换为 T 类型的右值引用（如果 T 是右值引用）或左值引用（如果 T 是左值引用）
+    // 这是因为 T&& 在模板中会根据 T 的实际类型（是否包含引用）表现为左值引用或右值引用
+    // 这种特性被称为“引用折叠”或“引用塌缩”
+    return static_cast<T&&>(arg); 
 }
-
+ 
+// 第二个模板，用于右值引用的情况
 template <class T>
-T&& forward(typename std::remove_reference<T>::type&& arg) noexcept
+T&& forward(typename std::remove_reference<T>::type&& arg) noexcept // 同样标记为 noexcept
 {
-  static_assert(!std::is_lvalue_reference<T>::value, "bad forward");
-  return static_cast<T&&>(arg);
+    // 使用 static_assert 进行编译期检查，确保 T 不是左值引用
+    // 如果 T 是左值引用，那么这个函数模板就不应该被实例化，因为它只处理右值引用的情况
+    static_assert(!std::is_lvalue_reference<T>::value, "bad forward: T must not be an lvalue reference");
+    
+    // 与第一个模板类似，使用 static_cast 将参数转换为 T 类型的引用
+    // 在这里，由于参数本身就是右值引用，所以转换后的类型也一定是右值引用
+    return static_cast<T&&>(arg);
 }
-
 // swap
 
+// 交换两个类型为 Tp 的对象 lhs 和 rhs 的值
 template <class Tp>
 void swap(Tp& lhs, Tp& rhs)
 {
+  // 使用 mystl::move 来移动 lhs 的值到临时对象 tmp
+  // 这样做可以避免在 lhs 和 rhs 相等时的自我赋值问题
   auto tmp(mystl::move(lhs));
+  // 将 rhs 的值移动到 lhs
   lhs = mystl::move(rhs);
+  // 将 tmp（原 lhs 的值）移动到 rhs
   rhs = mystl::move(tmp);
 }
 
+// 交换两个范围 [first1, last1) 和 [first2, first2 + (last1 - first1)) 的元素
 template <class ForwardIter1, class ForwardIter2>
 ForwardIter2 swap_range(ForwardIter1 first1, ForwardIter1 last1, ForwardIter2 first2)
 {
+  // 遍历两个范围，使用 mystl::swap 交换对应的元素
   for (; first1 != last1; ++first1, (void) ++first2)
     mystl::swap(*first1, *first2);
+  // 返回第二个范围的末尾迭代器
   return first2;
 }
 
+// 交换两个类型为 Tp 的数组 a 和 b，它们的大小都是 N
 template <class Tp, size_t N>
 void swap(Tp(&a)[N], Tp(&b)[N])
 {
+  // 使用 swap_range 函数来交换两个数组的元素
   mystl::swap_range(a, a + N, b);
 }
-
 // --------------------------------------------------------------------------------------
 // pair
 
 // 结构体模板 : pair
 // 两个模板参数分别表示两个数据的类型
 // 用 first 和 second 来分别取出第一个数据和第二个数据
+// 定义一个存储两个值的模板结构体 pair
 template <class Ty1, class Ty2>
 struct pair
 {
+  // 定义 pair 中两个元素的类型
   typedef Ty1    first_type;
   typedef Ty2    second_type;
 
+  // pair 的两个数据成员，存储两个不同类型的值
   first_type first;    // 保存第一个数据
   second_type second;  // 保存第二个数据
 
-  // default constructiable
-  template <class Other1 = Ty1, class Other2 = Ty2,
-    typename = typename std::enable_if<
-    std::is_default_constructible<Other1>::value &&
-    std::is_default_constructible<Other2>::value, void>::type>
-    constexpr pair()
+  // 默认构造函数，当两个类型都可以默认构造时
+  template <class U1 = Ty1, class U2 = Ty2,
+    typename std::enable_if<
+      std::is_default_constructible<U1>::value &&
+      std::is_default_constructible<U2>::value, void>::type>
+  constexpr pair()
     : first(), second()
   {
   }
 
-  // implicit constructiable for this type
+  // 拷贝构造函数，当两个类型都可以拷贝构造并且可以隐式转换时
   template <class U1 = Ty1, class U2 = Ty2,
     typename std::enable_if<
-    std::is_copy_constructible<U1>::value &&
-    std::is_copy_constructible<U2>::value &&
-    std::is_convertible<const U1&, Ty1>::value &&
-    std::is_convertible<const U2&, Ty2>::value, int>::type = 0>
-    constexpr pair(const Ty1& a, const Ty2& b)
+      std::is_copy_constructible<U1>::value &&
+      std::is_copy_constructible<U2>::value &&
+      std::is_convertible<const U1&, Ty1>::value &&
+      std::is_convertible<const U2&, Ty2>::value, int>::type>
+  constexpr pair(const Ty1& a, const Ty2& b)
     : first(a), second(b)
   {
   }
 
-  // explicit constructible for this type
+  // 显式拷贝构造函数，当两个类型都可以拷贝构造但不能隐式转换时
   template <class U1 = Ty1, class U2 = Ty2,
     typename std::enable_if<
-    std::is_copy_constructible<U1>::value &&
-    std::is_copy_constructible<U2>::value &&
-    (!std::is_convertible<const U1&, Ty1>::value ||
-     !std::is_convertible<const U2&, Ty2>::value), int>::type = 0>
-    explicit constexpr pair(const Ty1& a, const Ty2& b)
+      std::is_copy_constructible<U1>::value &&
+      std::is_copy_constructible<U2>::value &&
+      (!std::is_convertible<const U1&, Ty1>::value ||
+       !std::is_convertible<const U2&, Ty2>::value), int>::type>
+  explicit constexpr pair(const Ty1& a, const Ty2& b)
     : first(a), second(b)
   {
   }
 
+  // 拷贝赋值运算符，使用默认实现
   pair(const pair& rhs) = default;
+  // 移动构造函数，使用默认实现
   pair(pair&& rhs) = default;
 
-  // implicit constructiable for other type
+  // 完美转发构造函数，当两个类型都可以构造并且可以隐式转换时
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, Other1>::value &&
-    std::is_constructible<Ty2, Other2>::value &&
-    std::is_convertible<Other1&&, Ty1>::value &&
-    std::is_convertible<Other2&&, Ty2>::value, int>::type = 0>
-    constexpr pair(Other1&& a, Other2&& b)
+      std::is_constructible<Ty1, Other1>::value &&
+      std::is_constructible<Ty2, Other2>::value &&
+      std::is_convertible<Other1&&, Ty1>::value &&
+      std::is_convertible<Other2&&, Ty2>::value, int>::type>
+  constexpr pair(Other1&& a, Other2&& b)
     : first(mystl::forward<Other1>(a)),
-    second(mystl::forward<Other2>(b))
+      second(mystl::forward<Other2>(b))
   {
   }
 
-  // explicit constructiable for other type
+  // 显式完美转发构造函数，当两个类型都可以构造但不能隐式转换时
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, Other1>::value &&
-    std::is_constructible<Ty2, Other2>::value &&
-    (!std::is_convertible<Other1, Ty1>::value ||
-     !std::is_convertible<Other2, Ty2>::value), int>::type = 0>
-    explicit constexpr pair(Other1&& a, Other2&& b)
+      std::is_constructible<Ty1, Other1>::value &&
+      std::is_constructible<Ty2, Other2>::value &&
+      (!std::is_convertible<Other1, Ty1>::value ||
+       !std::is_convertible<Other2, Ty2>::value), int>::type>
+  explicit constexpr pair(Other1&& a, Other2&& b)
     : first(mystl::forward<Other1>(a)),
-    second(mystl::forward<Other2>(b))
+      second(mystl::forward<Other2>(b))
   {
   }
 
-  // implicit constructiable for other pair
+  // 拷贝构造函数，用于从其他类型的 pair 构造当前 pair
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, const Other1&>::value &&
-    std::is_constructible<Ty2, const Other2&>::value &&
-    std::is_convertible<const Other1&, Ty1>::value &&
-    std::is_convertible<const Other2&, Ty2>::value, int>::type = 0>
-    constexpr pair(const pair<Other1, Other2>& other)
+      std::is_constructible<Ty1, const Other1&>::value &&
+      std::is_constructible<Ty2, const Other2&>::value &&
+      std::is_convertible<const Other1&, Ty1>::value &&
+      std::is_convertible<const Other2&, Ty2>::value, int>::type>
+  constexpr pair(const pair<Other1, Other2>& other)
     : first(other.first),
-    second(other.second)
+      second(other.second)
   {
   }
 
-  // explicit constructiable for other pair
+  // 显式拷贝构造函数，用于从其他类型的 pair 构造当前 pair
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, const Other1&>::value &&
-    std::is_constructible<Ty2, const Other2&>::value &&
-    (!std::is_convertible<const Other1&, Ty1>::value ||
-     !std::is_convertible<const Other2&, Ty2>::value), int>::type = 0>
-    explicit constexpr pair(const pair<Other1, Other2>& other)
+      std::is_constructible<Ty1, const Other1&>::value &&
+      std::is_constructible<Ty2, const Other2&>::value &&
+      (!std::is_convertible<const Other1&, Ty1>::value ||
+       !std::is_convertible<const Other2&, Ty2>::value), int>::type>
+  explicit constexpr pair(const pair<Other1, Other2>& other)
     : first(other.first),
-    second(other.second)
+      second(other.second)
   {
   }
 
-  // implicit constructiable for other pair
+  // 完美转发构造函数，用于从其他类型的 pair 构造当前 pair
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, Other1>::value &&
-    std::is_constructible<Ty2, Other2>::value &&
-    std::is_convertible<Other1, Ty1>::value &&
-    std::is_convertible<Other2, Ty2>::value, int>::type = 0>
-    constexpr pair(pair<Other1, Other2>&& other)
+      std::is_constructible<Ty1, Other1>::value &&
+      std::is_constructible<Ty2, Other2>::value &&
+      std::is_convertible<Other1, Ty1>::value &&
+      std::is_convertible<Other2, Ty2>::value, int>::type>
+  constexpr pair(pair<Other1, Other2>&& other)
     : first(mystl::forward<Other1>(other.first)),
-    second(mystl::forward<Other2>(other.second))
+      second(mystl::forward<Other2>(other.second))
   {
   }
 
-  // explicit constructiable for other pair
+  // 显式完美转发构造函数，用于从其他类型的 pair 构造当前 pair
   template <class Other1, class Other2,
     typename std::enable_if<
-    std::is_constructible<Ty1, Other1>::value &&
-    std::is_constructible<Ty2, Other2>::value &&
-    (!std::is_convertible<Other1, Ty1>::value ||
-     !std::is_convertible<Other2, Ty2>::value), int>::type = 0>
-    explicit constexpr pair(pair<Other1, Other2>&& other)
+      std::is_constructible<Ty1, Other1>::value &&
+      std::is_constructible<Ty2, Other2>::value &&
+      (!std::is_convertible<Other1, Ty1>::value ||
+       !std::is_convertible<Other2, Ty2>::value), int>::type>
+  explicit constexpr pair(pair<Other1, Other2>&& other)
     : first(mystl::forward<Other1>(other.first)),
-    second(mystl::forward<Other2>(other.second))
+      second(mystl::forward<Other2>(other.second))
   {
   }
 
-  // copy assign for this pair
+  // 拷贝赋值运算符，将 rhs 的值赋给当前 pair 对象
   pair& operator=(const pair& rhs)
   {
     if (this != &rhs)
@@ -197,6 +219,7 @@ struct pair
     }
     return *this;
   }
+};
 
   // move assign for this pair
   pair& operator=(pair&& rhs)
@@ -219,71 +242,83 @@ struct pair
   }
 
   // move assign for other pair
-  template <class Other1, class Other2>
-  pair& operator=(pair<Other1, Other2>&& other)
-  {
-    first = mystl::forward<Other1>(other.first);
-    second = mystl::forward<Other2>(other.second);
-    return *this;
-  }
+  // 移动赋值运算符，用于将另一个 pair 对象的值移动到当前 pair 对象中
+template <class Other1, class Other2>
+pair& operator=(pair<Other1, Other2>&& other)
+{
+  // 使用完美转发将 other 对象的第一个值移动到当前对象的第一个值
+  first = mystl::forward<Other1>(other.first);
+  // 使用完美转发将 other 对象的第二个值移动到当前对象的第二个值
+  second = mystl::forward<Other2>(other.second);
+  // 返回当前对象的引用
+  return *this;
+}
 
-  ~pair() = default;
+// 析构函数，使用默认的析构函数
+~pair() = default;
 
-  void swap(pair& other)
+// 交换当前 pair 对象与另一个 pair 对象的值
+void swap(pair& other)
+{
+  // 如果两个 pair 对象不是同一个对象，则进行交换
+  if (this != &other)
   {
-    if (this != &other)
-    {
-      mystl::swap(first, other.first);
-      mystl::swap(second, other.second);
-    }
+    // 交换第一个值
+    mystl::swap(first, other.first);
+    // 交换第二个值
+    mystl::swap(second, other.second);
   }
-
-};
+}
 
 // 重载比较操作符 
+// 比较两个 pair 对象是否相等
 template <class Ty1, class Ty2>
 bool operator==(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果两个 pair 对象的第一个元素和第二个元素都相等，则返回 true
   return lhs.first == rhs.first && lhs.second == rhs.second;
 }
 
+// 比较两个 pair 对象的大小
 template <class Ty1, class Ty2>
 bool operator<(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果第一个元素小于 rhs 的第一个元素，或者第一个元素相等且第二个元素小于 rhs 的第二个元素，则返回 true
   return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);
 }
 
+// 比较两个 pair 对象是否不相等
 template <class Ty1, class Ty2>
 bool operator!=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果两个 pair 对象不相等，则返回 true
   return !(lhs == rhs);
 }
 
+// 比较两个 pair 对象的大小，反向比较
 template <class Ty1, class Ty2>
 bool operator>(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果 rhs 对象小于 lhs 对象，则返回 true
   return rhs < lhs;
 }
 
+// 比较两个 pair 对象的大小，反向比较小于或等于
 template <class Ty1, class Ty2>
 bool operator<=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果 rhs 对象小于 lhs 对象，则返回 false，否则返回 true
   return !(rhs < lhs);
 }
 
+// 比较两个 pair 对象的大小，反向比较大于或等于
 template <class Ty1, class Ty2>
 bool operator>=(const pair<Ty1, Ty2>& lhs, const pair<Ty1, Ty2>& rhs)
 {
+  // 如果 lhs 对象小于 rhs 对象，则返回 false，否则返回 true
   return !(lhs < rhs);
 }
 
-// 重载 mystl 的 swap
-template <class Ty1, class Ty2>
-void swap(pair<Ty1, Ty2>& lhs, pair<Ty1, Ty2>& rhs)
-{
-  lhs.swap(rhs);
-}
-
 // 全局函数，让两个数据成为一个 pair
 template <class Ty1, class Ty2>
 pair<Ty1, Ty2> make_pair(Ty1&& first, Ty2&& second)

MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h

@@ -70,58 +70,71 @@ private:
 
 public:
   // 构造、复制、移动、析构函数
-  vector() noexcept
+// 构造一个空的 vector 对象，不抛出异常
+vector() noexcept
   { try_init(); }
 
-  explicit vector(size_type n)
+// 构造一个包含 n 个默认初始化元素的 vector 对象
+explicit vector(size_type n)
   { fill_init(n, value_type()); }
 
-  vector(size_type n, const value_type& value)
+// 构造一个包含 n 个指定值 value 的 vector 对象
+vector(size_type n, const value_type& value)
   { fill_init(n, value); }
 
-  template <class Iter, typename std::enable_if<
-    mystl::is_input_iterator<Iter>::value, int>::type = 0>
-  vector(Iter first, Iter last)
-  {
-    MYSTL_DEBUG(!(last < first));
-    range_init(first, last);
-  }
+// 模板构造函数，构造一个包含 [first, last) 范围内元素的 vector 对象
+// 要求 Iter 是输入迭代器
+template <class Iter, typename std::enable_if<
+  mystl::is_input_iterator<Iter>::value, int>::type = 0>
+vector(Iter first, Iter last)
+{
+  MYSTL_DEBUG(!(last < first)); // 确保 first 在 last 之前
+  range_init(first, last); // 初始化范围
+}
 
-  vector(const vector& rhs)
-  {
-    range_init(rhs.begin_, rhs.end_);
-  }
+// 拷贝构造函数，构造一个与 rhs 相等的 vector 对象
+vector(const vector& rhs)
+{
+  range_init(rhs.begin_, rhs.end_); // 使用范围初始化
+}
 
-  vector(vector&& rhs) noexcept
-    :begin_(rhs.begin_),
-    end_(rhs.end_),
-    cap_(rhs.cap_)
-  {
-    rhs.begin_ = nullptr;
-    rhs.end_ = nullptr;
-    rhs.cap_ = nullptr;
-  }
+// 移动构造函数，构造一个与 rhs 相等的 vector 对象，不抛出异常
+vector(vector&& rhs) noexcept
+  :begin_(rhs.begin_),
+  end_(rhs.end_),
+  cap_(rhs.cap_)
+{
+  rhs.begin_ = nullptr; // 将 rhs 的资源置空
+  rhs.end_ = nullptr;
+  rhs.cap_ = nullptr;
+}
 
-  vector(std::initializer_list<value_type> ilist)
-  {
-    range_init(ilist.begin(), ilist.end());
-  }
+// 构造一个包含 initializer_list 中元素的 vector 对象
+vector(std::initializer_list<value_type> ilist)
+{
+  range_init(ilist.begin(), ilist.end()); // 使用范围初始化
+}
 
-  vector& operator=(const vector& rhs);
-  vector& operator=(vector&& rhs) noexcept;
+// 拷贝赋值运算符，将 rhs 的内容赋值给当前 vector 对象
+vector& operator=(const vector& rhs);
 
-  vector& operator=(std::initializer_list<value_type> ilist)
-  {
-    vector tmp(ilist.begin(), ilist.end());
-    swap(tmp);
-    return *this;
-  }
+// 移动赋值运算符，将 rhs 的内容移动到当前 vector 对象，不抛出异常
+vector& operator=(vector&& rhs) noexcept;
 
-  ~vector()
-  { 
-    destroy_and_recover(begin_, end_, cap_ - begin_);
-    begin_ = end_ = cap_ = nullptr;
-  }
+// 接受一个 initializer_list 并将其内容赋值给当前 vector 对象
+vector& operator=(std::initializer_list<value_type> ilist)
+{
+  vector tmp(ilist.begin(), ilist.end()); // 创建临时 vector
+  swap(tmp); // 交换当前 vector 与临时 vector 的内容
+  return *this;
+}
+
+// 析构函数，释放 vector 对象占用的资源
+~vector()
+{ 
+  destroy_and_recover(begin_, end_, cap_ - begin_); // 销毁并回收元素
+  begin_ = end_ = cap_ = nullptr; // 将指针置空
+}
 
 public:
 
@@ -326,33 +339,49 @@ private:
 /*****************************************************************************************/
 
 // 复制赋值操作符
+
+// 拷贝赋值运算符，将另一个 vector 对象 rhs 的内容赋值给当前 vector 对象
 template <class T>
 vector<T>& vector<T>::operator=(const vector& rhs)
 {
+  // 如果当前对象和 rhs 不是同一个对象，则继续赋值操作
   if (this != &rhs)
   {
+    // 获取 rhs 的长度（元素数量）
     const auto len = rhs.size();
+    
+    // 如果 rhs 的容量大于当前 vector 的容量，需要重新分配内存
     if (len > capacity())
     { 
+      // 创建一个临时 vector 对象 tmp，包含 rhs 的所有元素
       vector tmp(rhs.begin(), rhs.end());
+      // 交换当前 vector 对象和临时 vector 对象的内容
       swap(tmp);
     }
-    else if (size() >= len)
+    else if (size() >= len) // 如果当前 vector 的容量足够大
     {
+      // 使用 mystl::copy 函数将 rhs 的元素复制到当前 vector 的开始位置
       auto i = mystl::copy(rhs.begin(), rhs.end(), begin());
+      // 销毁多余的元素
       data_allocator::destroy(i, end_);
+      // 更新 end_ 指针的位置
       end_ = begin_ + len;
     }
-    else
+    else // 如果当前 vector 的容量不足以容纳 rhs 的所有元素，但足以容纳当前的元素
     { 
+      // 将 rhs 的元素复制到当前 vector 的开始位置，覆盖现有的元素
       mystl::copy(rhs.begin(), rhs.begin() + size(), begin_);
+      // 使用 uninitialized_copy 将 rhs 的剩余元素复制到当前 vector 的末尾
       mystl::uninitialized_copy(rhs.begin() + size(), rhs.end(), end_);
+      // 更新容量和 end_ 指针的位置
       cap_ = end_ = begin_ + len;
     }
   }
+  // 返回当前 vector 对象的引用
   return *this;
 }
 
+
 // 移动赋值操作符
 template <class T>
 vector<T>& vector<T>::operator=(vector&& rhs) noexcept
@@ -368,19 +397,29 @@ vector<T>& vector<T>::operator=(vector&& rhs) noexcept
 }
 
 // 预留空间大小，当原容量小于要求大小时，才会重新分配
+// vector<T>::reserve 函数，调整 vector 的容量至少为 n，如果当前容量已经足够则不作任何操作
 template <class T>
 void vector<T>::reserve(size_type n)
 {
+  // 如果当前 vector 的容量小于 n，则需要扩容
   if (capacity() < n)
   {
+    // 如果请求的容量超过了 vector 最大可能的容量，则抛出长度错误异常
     THROW_LENGTH_ERROR_IF(n > max_size(),
                           "n can not larger than max_size() in vector<T>::reserve(n)");
+    // 保存当前 vector 的大小（元素数量）
     const auto old_size = size();
+    // 分配新的内存空间，容量为 n
     auto tmp = data_allocator::allocate(n);
+    // 将旧内存空间中的所有元素移动到新内存空间
     mystl::uninitialized_move(begin_, end_, tmp);
+    // 释放旧的内存空间
     data_allocator::deallocate(begin_, cap_ - begin_);
+    // 更新 vector 的开始指针为新的内存空间
     begin_ = tmp;
+    // 更新 vector 的结束指针为新内存空间的末尾（不包括新分配的未使用空间）
     end_ = tmp + old_size;
+    // 更新 vector 的容量指针
     cap_ = begin_ + n;
   }
 }
@@ -466,32 +505,48 @@ void vector<T>::pop_back()
 }
 
 // 在 pos 处插入元素
+// 在指定位置 pos 插入一个值 value 的副本
 template <class T>
 typename vector<T>::iterator
 vector<T>::insert(const_iterator pos, const value_type& value)
 {
+  // 调试断言，确保 pos 在有效范围内
   MYSTL_DEBUG(pos >= begin() && pos <= end());
+  // 将 const_iterator 转换为 iterator
   iterator xpos = const_cast<iterator>(pos);
+  // 计算 pos 到 begin() 的距离
   const size_type n = pos - begin_;
+  // 如果 vector 未满且插入位置在末尾
   if (end_ != cap_ && xpos == end_)
   {
+    // 在末尾就地构造新元素
     data_allocator::construct(mystl::address_of(*end_), value);
+    // 移动 end_ 指针
     ++end_;
   }
   else if (end_ != cap_)
   {
+    // 在非满的 vector 中插入元素
     auto new_end = end_;
+    // 在末尾就地构造一个临时元素
     data_allocator::construct(mystl::address_of(*end_), *(end_ - 1));
+    // 移动末尾元素
     ++new_end;
-    auto value_copy = value;  // 避免元素因以下复制操作而被改变
+    // 复制值以避免在复制过程中被覆盖
+    auto value_copy = value;  
+    // 从插入点开始，将元素向后复制
     mystl::copy_backward(xpos, end_ - 1, end_);
+    // 插入新元素
     *xpos = mystl::move(value_copy);
+    // 更新 end_ 指针
     end_ = new_end;
   }
   else
   {
+    // 如果 vector 已满，需要重新分配内存并插入元素
     reallocate_insert(xpos, value);
   }
+  // 返回插入元素的位置
   return begin_ + n;
 }
 
@@ -619,25 +674,32 @@ destroy_and_recover(iterator first, iterator last, size_type n)
 }
 
 // get_new_cap 函数
+// 计算 vector 需要的新容量
 template <class T>
 typename vector<T>::size_type 
-vector<T>::
-get_new_cap(size_type add_size)
+vector<T>::get_new_cap(size_type add_size)
 {
+  // 获取当前 vector 的容量
   const auto old_size = capacity();
+  // 如果添加的元素数量使得新容量超过最大可能的容量，则抛出长度错误异常
   THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size,
                         "vector<T>'s size too big");
+  // 如果当前容量加上一半的容量或者添加的元素数量超过了最大容量减去16，
+  // 则直接计算新容量为当前容量加上添加的元素数量
   if (old_size > max_size() - old_size / 2)
   {
+    // 计算新容量，确保不超过最大容量
     return old_size + add_size > max_size() - 16
       ? old_size + add_size : old_size + add_size + 16;
   }
+  // 如果当前容量为0，新容量至少为添加的元素数量或16（取较大者）
+  // 否则，新容量为当前容量的1.5倍和当前容量加上添加的元素数量中较大的一个
   const size_type new_size = old_size == 0
     ? mystl::max(add_size, static_cast<size_type>(16))
     : mystl::max(old_size + old_size / 2, old_size + add_size);
+  // 返回计算出的新容量
   return new_size;
 }
-
 // fill_assign 函数
 template <class T>
 void vector<T>::
@@ -681,29 +743,39 @@ copy_assign(IIter first, IIter last, input_iterator_tag)
 }
 
 // 用 [first, last) 为容器赋值
+// 使用 forward_iterator_tag 标记的迭代器从范围 [first, last) 复制并分配元素给当前 vector
 template <class T>
 template <class FIter>
-void vector<T>::
-copy_assign(FIter first, FIter last, forward_iterator_tag)
+void vector<T>::copy_assign(FIter first, FIter last, forward_iterator_tag)
 {
+  // 计算要复制的元素数量
   const size_type len = mystl::distance(first, last);
+  // 如果要复制的元素数量大于当前 vector 的容量，则需要创建一个新的临时 vector
   if (len > capacity())
   {
+    // 创建一个临时 vector 并交换内容
     vector tmp(first, last);
     swap(tmp);
   }
-  else if (size() >= len)
+  else if (size() >= len) // 如果当前 vector 的大小足以容纳所有元素
   {
+    // 使用 mystl::copy 将元素复制到 vector 的开始位置
     auto new_end = mystl::copy(first, last, begin_);
+    // 销毁多余的元素
     data_allocator::destroy(new_end, end_);
+    // 更新 end_ 指针
     end_ = new_end;
   }
-  else
+  else // 如果当前 vector 的大小不足以容纳所有元素，但小于要复制的元素数量
   {
+    // 计算 mid 指针，指向要复制的元素的中点
     auto mid = first;
     mystl::advance(mid, size());
+    // 将前 size() 个元素复制到 vector 的开始位置
     mystl::copy(first, mid, begin_);
+    // 使用 uninitialized_copy 将剩余的元素复制到 vector 的末尾
     auto new_end = mystl::uninitialized_copy(mid, last, end_);
+    // 更新 end_ 指针
     end_ = new_end;
   }
 }
@@ -736,26 +808,38 @@ reallocate_emplace(iterator pos, Args&& ...args)
 }
 
 // 重新分配空间并在 pos 处插入元素
+// 在指定位置 pos 插入值 value 时，如果需要，重新分配内存以插入元素
 template <class T>
 void vector<T>::reallocate_insert(iterator pos, const value_type& value)
 {
+  // 计算插入新元素后所需的新容量
   const auto new_size = get_new_cap(1);
+  // 分配新的内存空间
   auto new_begin = data_allocator::allocate(new_size);
+  // 初始化 new_end 指针为新内存空间的开始
   auto new_end = new_begin;
+  // 复制 value 以避免在以下操作中被修改
   const value_type& value_copy = value;
   try
   {
+    // 将 [begin_, pos) 区间的元素移动到新内存空间
     new_end = mystl::uninitialized_move(begin_, pos, new_begin);
+    // 在新内存空间中 pos 对应的位置构造新元素
     data_allocator::construct(mystl::address_of(*new_end), value_copy);
+    // 移动 new_end 指针
     ++new_end;
+    // 将 [pos, end_) 区间的元素移动到新内存空间
     new_end = mystl::uninitialized_move(pos, end_, new_end);
   }
   catch (...)
   {
+    // 如果发生异常，释放新分配的内存并重新抛出异常
     data_allocator::deallocate(new_begin, new_size);
     throw;
   }
+  // 销毁旧内存空间中的元素并释放内存
   destroy_and_recover(begin_, end_, cap_ - begin_);
+  // 更新 vector 的指针为新内存空间
   begin_ = new_begin;
   end_ = new_end;
   cap_ = new_begin + new_size;