From e5fdcccf296497d6961c6e9ed2a262bb2136217c Mon Sep 17 00:00:00 2001 From: caoxin Date: Mon, 16 Dec 2024 21:04:44 +0800 Subject: [PATCH] update vector.h util.h unordered_ste.h --- .../MyTinySTL/unordered_set.h | 310 ++++++++++++------ .../MyTinySTL-master/MyTinySTL/util.h | 219 +++++++------ .../MyTinySTL-master/MyTinySTL/vector.h | 184 ++++++++--- 3 files changed, 473 insertions(+), 240 deletions(-) mode change 100644 => 100755 MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h mode change 100644 => 100755 MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h mode change 100644 => 100755 MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h diff --git a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h b/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h old mode 100644 new mode 100755 index eb60589..ad5a2c1 --- a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h +++ b/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/unordered_set.h @@ -144,44 +144,94 @@ public: // empalce / empalce_hint template - pair emplace(Args&& ...args) - { return ht_.emplace_unique(mystl::forward(args)...); } +pair emplace(Args&& ...args) +{ + // 使用哈希表的 emplace_unique 方法插入元素 + return ht_.emplace_unique(mystl::forward(args)...); +} - template - iterator emplace_hint(const_iterator hint, Args&& ...args) - { return ht_.emplace_unique_use_hint(hint, mystl::forward(args)...); } +// 就地构造并插入一个新的元素，使用 hint 提示位置 +template +iterator emplace_hint(const_iterator hint, Args&& ...args) +{ + // 使用哈希表的 emplace_unique_use_hint 方法插入元素 + return ht_.emplace_unique_use_hint(hint, mystl::forward(args)...); +} - // insert +// 插入元素 - pair insert(const value_type& value) - { return ht_.insert_unique(value); } - pair insert(value_type&& value) - { return ht_.emplace_unique(mystl::move(value)); } +// 插入一个值等于 value 的元素 +pair 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 insert(value_type&& value) +{ + // 使用哈希表的 emplace_unique 方法插入元素 + return ht_.emplace_unique(mystl::move(value)); +} - template - 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 +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 - unordered_multiset(InputIterator first, InputIterator last, +// 模板构造函数，创建一个包含指定范围元素的 unordered_multiset，可能还会指定桶的数量和哈希函数和键值比较函数 +template +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(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 ilist, +// 构造函数，创建一个包含 initializer_list 中元素的 unordered_multiset，可能还会指定桶的数量和哈希函数和键值比较函数 +unordered_multiset(std::initializer_list ilist, const size_type bucket_count = 100, const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual()) :ht_(mystl::max(bucket_count, static_cast(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 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 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 - iterator emplace(Args&& ...args) - { return ht_.emplace_multi(mystl::forward(args)...); } +iterator emplace(Args&& ...args) +{ + // 使用哈希表的 emplace_multi 方法插入元素 + return ht_.emplace_multi(mystl::forward(args)...); +} - template - iterator emplace_hint(const_iterator hint, Args&& ...args) - { return ht_.emplace_multi_use_hint(hint, mystl::forward(args)...); } +// 就地构造并插入一个新的元素，使用 hint 提示位置 +template +iterator emplace_hint(const_iterator hint, Args&& ...args) +{ + // 使用哈希表的 emplace_multi_use_hint 方法插入元素 + return ht_.emplace_multi_use_hint(hint, mystl::forward(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 - 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 +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_); +} // 查找相关 diff --git a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h b/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h old mode 100644 new mode 100755 index df6d583..49db96d --- a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h +++ b/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/util.h @@ -21,173 +21,195 @@ typename std::remove_reference::type&& move(T&& arg) noexcept // forward template -T&& forward(typename std::remove_reference::type& arg) noexcept +T&& forward(typename std::remove_reference::type& arg) noexcept // noexcept 表示函数不会抛出异常 { - return static_cast(arg); + // 使用 static_cast 将左值引用转换为 T 类型的右值引用（如果 T 是右值引用）或左值引用（如果 T 是左值引用） + // 这是因为 T&& 在模板中会根据 T 的实际类型（是否包含引用）表现为左值引用或右值引用 + // 这种特性被称为“引用折叠”或“引用塌缩” + return static_cast(arg); } - + +// 第二个模板，用于右值引用的情况 template -T&& forward(typename std::remove_reference::type&& arg) noexcept +T&& forward(typename std::remove_reference::type&& arg) noexcept // 同样标记为 noexcept { - static_assert(!std::is_lvalue_reference::value, "bad forward"); - return static_cast(arg); + // 使用 static_assert 进行编译期检查，确保 T 不是左值引用 + // 如果 T 是左值引用，那么这个函数模板就不应该被实例化，因为它只处理右值引用的情况 + static_assert(!std::is_lvalue_reference::value, "bad forward: T must not be an lvalue reference"); + + // 与第一个模板类似，使用 static_cast 将参数转换为 T 类型的引用 + // 在这里，由于参数本身就是右值引用，所以转换后的类型也一定是右值引用 + return static_cast(arg); } - // swap +// 交换两个类型为 Tp 的对象 lhs 和 rhs 的值 template 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 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 void swap(Tp(&a)[N], Tp(&b)[N]) { + // 使用 swap_range 函数来交换两个数组的元素 mystl::swap_range(a, a + N, b); } - // -------------------------------------------------------------------------------------- // pair // 结构体模板 : pair // 两个模板参数分别表示两个数据的类型 // 用 first 和 second 来分别取出第一个数据和第二个数据 +// 定义一个存储两个值的模板结构体 pair template struct pair { + // 定义 pair 中两个元素的类型 typedef Ty1 first_type; typedef Ty2 second_type; + // pair 的两个数据成员，存储两个不同类型的值 first_type first; // 保存第一个数据 second_type second; // 保存第二个数据 - // default constructiable - template ::value && - std::is_default_constructible::value, void>::type> - constexpr pair() + // 默认构造函数，当两个类型都可以默认构造时 + template ::value && + std::is_default_constructible::value, void>::type> + constexpr pair() : first(), second() { } - // implicit constructiable for this type + // 拷贝构造函数，当两个类型都可以拷贝构造并且可以隐式转换时 template ::value && - std::is_copy_constructible::value && - std::is_convertible::value && - std::is_convertible::value, int>::type = 0> - constexpr pair(const Ty1& a, const Ty2& b) + std::is_copy_constructible::value && + std::is_copy_constructible::value && + std::is_convertible::value && + std::is_convertible::value, int>::type> + constexpr pair(const Ty1& a, const Ty2& b) : first(a), second(b) { } - // explicit constructible for this type + // 显式拷贝构造函数，当两个类型都可以拷贝构造但不能隐式转换时 template ::value && - std::is_copy_constructible::value && - (!std::is_convertible::value || - !std::is_convertible::value), int>::type = 0> - explicit constexpr pair(const Ty1& a, const Ty2& b) + std::is_copy_constructible::value && + std::is_copy_constructible::value && + (!std::is_convertible::value || + !std::is_convertible::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 ::value && - std::is_constructible::value && - std::is_convertible::value && - std::is_convertible::value, int>::type = 0> - constexpr pair(Other1&& a, Other2&& b) + std::is_constructible::value && + std::is_constructible::value && + std::is_convertible::value && + std::is_convertible::value, int>::type> + constexpr pair(Other1&& a, Other2&& b) : first(mystl::forward(a)), - second(mystl::forward(b)) + second(mystl::forward(b)) { } - // explicit constructiable for other type + // 显式完美转发构造函数，当两个类型都可以构造但不能隐式转换时 template ::value && - std::is_constructible::value && - (!std::is_convertible::value || - !std::is_convertible::value), int>::type = 0> - explicit constexpr pair(Other1&& a, Other2&& b) + std::is_constructible::value && + std::is_constructible::value && + (!std::is_convertible::value || + !std::is_convertible::value), int>::type> + explicit constexpr pair(Other1&& a, Other2&& b) : first(mystl::forward(a)), - second(mystl::forward(b)) + second(mystl::forward(b)) { } - // implicit constructiable for other pair + // 拷贝构造函数，用于从其他类型的 pair 构造当前 pair template ::value && - std::is_constructible::value && - std::is_convertible::value && - std::is_convertible::value, int>::type = 0> - constexpr pair(const pair& other) + std::is_constructible::value && + std::is_constructible::value && + std::is_convertible::value && + std::is_convertible::value, int>::type> + constexpr pair(const pair& other) : first(other.first), - second(other.second) + second(other.second) { } - // explicit constructiable for other pair + // 显式拷贝构造函数，用于从其他类型的 pair 构造当前 pair template ::value && - std::is_constructible::value && - (!std::is_convertible::value || - !std::is_convertible::value), int>::type = 0> - explicit constexpr pair(const pair& other) + std::is_constructible::value && + std::is_constructible::value && + (!std::is_convertible::value || + !std::is_convertible::value), int>::type> + explicit constexpr pair(const pair& other) : first(other.first), - second(other.second) + second(other.second) { } - // implicit constructiable for other pair + // 完美转发构造函数，用于从其他类型的 pair 构造当前 pair template ::value && - std::is_constructible::value && - std::is_convertible::value && - std::is_convertible::value, int>::type = 0> - constexpr pair(pair&& other) + std::is_constructible::value && + std::is_constructible::value && + std::is_convertible::value && + std::is_convertible::value, int>::type> + constexpr pair(pair&& other) : first(mystl::forward(other.first)), - second(mystl::forward(other.second)) + second(mystl::forward(other.second)) { } - // explicit constructiable for other pair + // 显式完美转发构造函数，用于从其他类型的 pair 构造当前 pair template ::value && - std::is_constructible::value && - (!std::is_convertible::value || - !std::is_convertible::value), int>::type = 0> - explicit constexpr pair(pair&& other) + std::is_constructible::value && + std::is_constructible::value && + (!std::is_convertible::value || + !std::is_convertible::value), int>::type> + explicit constexpr pair(pair&& other) : first(mystl::forward(other.first)), - second(mystl::forward(other.second)) + second(mystl::forward(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 - pair& operator=(pair&& other) - { - first = mystl::forward(other.first); - second = mystl::forward(other.second); - return *this; - } + // 移动赋值运算符，用于将另一个 pair 对象的值移动到当前 pair 对象中 +template +pair& operator=(pair&& other) +{ + // 使用完美转发将 other 对象的第一个值移动到当前对象的第一个值 + first = mystl::forward(other.first); + // 使用完美转发将 other 对象的第二个值移动到当前对象的第二个值 + second = mystl::forward(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 bool operator==(const pair& lhs, const pair& rhs) { + // 如果两个 pair 对象的第一个元素和第二个元素都相等，则返回 true return lhs.first == rhs.first && lhs.second == rhs.second; } +// 比较两个 pair 对象的大小 template bool operator<(const pair& lhs, const pair& rhs) { + // 如果第一个元素小于 rhs 的第一个元素，或者第一个元素相等且第二个元素小于 rhs 的第二个元素，则返回 true return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second); } +// 比较两个 pair 对象是否不相等 template bool operator!=(const pair& lhs, const pair& rhs) { + // 如果两个 pair 对象不相等，则返回 true return !(lhs == rhs); } +// 比较两个 pair 对象的大小，反向比较 template bool operator>(const pair& lhs, const pair& rhs) { + // 如果 rhs 对象小于 lhs 对象，则返回 true return rhs < lhs; } +// 比较两个 pair 对象的大小，反向比较小于或等于 template bool operator<=(const pair& lhs, const pair& rhs) { + // 如果 rhs 对象小于 lhs 对象，则返回 false，否则返回 true return !(rhs < lhs); } +// 比较两个 pair 对象的大小，反向比较大于或等于 template bool operator>=(const pair& lhs, const pair& rhs) { + // 如果 lhs 对象小于 rhs 对象，则返回 false，否则返回 true return !(lhs < rhs); } -// 重载 mystl 的 swap -template -void swap(pair& lhs, pair& rhs) -{ - lhs.swap(rhs); -} - // 全局函数，让两个数据成为一个 pair template pair make_pair(Ty1&& first, Ty2&& second) diff --git a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h b/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h old mode 100644 new mode 100755 index 5192761..ac1e7b9 --- a/MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h +++ b/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 ::value, int>::type = 0> - vector(Iter first, Iter last) - { - MYSTL_DEBUG(!(last < first)); - range_init(first, last); - } +// 模板构造函数，构造一个包含 [first, last) 范围内元素的 vector 对象 +// 要求 Iter 是输入迭代器 +template ::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 ilist) - { - range_init(ilist.begin(), ilist.end()); - } +// 构造一个包含 initializer_list 中元素的 vector 对象 +vector(std::initializer_list 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 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 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 vector& vector::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 vector& vector::operator=(vector&& rhs) noexcept @@ -368,19 +397,29 @@ vector& vector::operator=(vector&& rhs) noexcept } // 预留空间大小，当原容量小于要求大小时，才会重新分配 +// vector::reserve 函数，调整 vector 的容量至少为 n，如果当前容量已经足够则不作任何操作 template void vector::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::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::pop_back() } // 在 pos 处插入元素 +// 在指定位置 pos 插入一个值 value 的副本 template typename vector::iterator vector::insert(const_iterator pos, const value_type& value) { + // 调试断言，确保 pos 在有效范围内 MYSTL_DEBUG(pos >= begin() && pos <= end()); + // 将 const_iterator 转换为 iterator iterator xpos = const_cast(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 typename vector::size_type -vector:: -get_new_cap(size_type add_size) +vector::get_new_cap(size_type add_size) { + // 获取当前 vector 的容量 const auto old_size = capacity(); + // 如果添加的元素数量使得新容量超过最大可能的容量，则抛出长度错误异常 THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size, "vector'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(16)) : mystl::max(old_size + old_size / 2, old_size + add_size); + // 返回计算出的新容量 return new_size; } - // fill_assign 函数 template void vector:: @@ -681,29 +743,39 @@ copy_assign(IIter first, IIter last, input_iterator_tag) } // 用 [first, last) 为容器赋值 +// 使用 forward_iterator_tag 标记的迭代器从范围 [first, last) 复制并分配元素给当前 vector template template -void vector:: -copy_assign(FIter first, FIter last, forward_iterator_tag) +void vector::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 void vector::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;