pfuc5ij8g
/
MyTinySTL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

以上注释提供了对 vector 模板类实现细节的全面解释。它们涵盖了 vector 的构造函数、复制和移动赋值操作符、内存分配和释放、元素插入与删除、容量调整以及元素赋值等功能。每个成员函数的注释详细描述了函数的行为、参数的作用以及任何异常处理。此外，还包括了对比较操作符的重载和 swap 函数的实现，这些都是为了提供完整的 vector 容器功能。这些注释旨在帮助开发者理解 vector 类的内部机制和实现逻辑，以便更有效地使用和维护该容器。

Browse Source
main
sunjiawei 8 months ago
parent 6725415db5
commit 2275a6a510
1 changed files with 446 additions and 588 deletions
Show Stats Download Patch File Download Diff File

618
src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/vector.h
Unescape View File

@ -16,17 +16,17 @@
// * resize // * resize
// * insert // * insert
#include <initializer_list> #include <initializer_list> // 包含初始化列表相关头文件
#include "iterator.h" #include "iterator.h" // 包含自定义迭代器相关实现
#include "memory.h" #include "memory.h" // 包含自定义内存分配器相关实现
#include "util.h" #include "util.h" // 包含一些实用工具函数
#include "exceptdef.h" #include "exceptdef.h" // 包含异常定义
#include "algo.h" #include "algo.h" // 包含算法实现
namespace mystl namespace mystl
{ {
// 取消宏定义 max 和 min，避免与标准库中的同名函数冲突
#ifdef max #ifdef max
#pragma message("#undefing marco max") #pragma message("#undefing marco max")
#undef max #undef max
@ -45,24 +45,23 @@ class vector
static_assert(!std::is_same<bool, T>::value, "vector<bool> is abandoned in mystl"); static_assert(!std::is_same<bool, T>::value, "vector<bool> is abandoned in mystl");
public: public:
// vector 的嵌套型别定义 // vector 的嵌套型别定义
typedef mystl::allocator<T> allocator_type; typedef mystl::allocator<T> allocator_type; // 分配器类型
typedef mystl::allocator<T> data_allocator; typedef mystl::allocator<T> data_allocator; // 数据分配器类型
typedef typename allocator_type::value_type value_type; typedef typename allocator_type::value_type value_type; // 元素类型
typedef typename allocator_type::pointer pointer; typedef typename allocator_type::pointer pointer; // 指针类型
typedef typename allocator_type::const_pointer const_pointer; typedef typename allocator_type::const_pointer const_pointer; // 常量指针类型
typedef typename allocator_type::reference reference; typedef typename allocator_type::reference reference; // 引用类型
typedef typename allocator_type::const_reference const_reference; typedef typename allocator_type::const_reference const_reference; // 常量引用类型
typedef typename allocator_type::size_type size_type; typedef typename allocator_type::size_type size_type; // 大小类型
typedef typename allocator_type::difference_type difference_type; typedef typename allocator_type::difference_type difference_type; // 差值类型
typedef value_type* iterator; typedef value_type* iterator; // 迭代器类型
typedef const value_type* const_iterator; typedef const value_type* const_iterator; // 常量迭代器类型
typedef mystl::reverse_iterator<iterator> reverse_iterator; typedef mystl::reverse_iterator<iterator> reverse_iterator;// 反向迭代器类型
typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator; typedef mystl::reverse_iterator<const_iterator> const_reverse_iterator;// 常量反向迭代器类型
allocator_type get_allocator() { return data_allocator(); } allocator_type get_allocator() { return data_allocator(); } // 获取分配器
private: private:
iterator begin_; // 表示目前使用空间的头部 iterator begin_; // 表示目前使用空间的头部
iterator end_; // 表示目前使用空间的尾部 iterator end_; // 表示目前使用空间的尾部
@ -70,15 +69,22 @@ private:
public: public:
// 构造、复制、移动、析构函数 // 构造、复制、移动、析构函数
vector() noexcept vector() noexcept // 默认构造函数
{ try_init(); } {
try_init();
}
explicit vector(size_type n) explicit vector(size_type n) // 构造函数，初始化指定数量的元素
{ fill_init(n, value_type()); } {
fill_init(n, value_type());
}
vector(size_type n, const value_type& value) vector(size_type n, const value_type& value) // 构造函数，初始化指定数量的相同元素
{ fill_init(n, value); } {
fill_init(n, value);
}
// 构造函数，使用迭代器范围初始化
template <class Iter, typename std::enable_if< template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0> mystl::is_input_iterator<Iter>::value, int>::type = 0>
vector(Iter first, Iter last) vector(Iter first, Iter last)
@ -87,12 +93,12 @@ public:
range_init(first, last); range_init(first, last);
} }
vector(const vector& rhs) vector(const vector& rhs) // 复制构造函数
{ {
range_init(rhs.begin_, rhs.end_); range_init(rhs.begin_, rhs.end_);
} }
vector(vector&& rhs) noexcept vector(vector&& rhs) noexcept // 移动构造函数
:begin_(rhs.begin_), :begin_(rhs.begin_),
end_(rhs.end_), end_(rhs.end_),
cap_(rhs.cap_) cap_(rhs.cap_)
@ -102,14 +108,15 @@ public:
rhs.cap_ = nullptr; rhs.cap_ = nullptr;
} }
vector(std::initializer_list<value_type> ilist) vector(std::initializer_list<value_type> ilist) // 初始化列表构造函数
{ {
range_init(ilist.begin(), ilist.end()); range_init(ilist.begin(), ilist.end());
} }
vector& operator=(const vector& rhs); vector& operator=(const vector& rhs); // 复制赋值操作符
vector& operator=(vector&& rhs) noexcept; vector& operator=(vector&& rhs) noexcept; // 移动赋值操作符
// 赋值操作符，使用初始化列表
vector& operator=(std::initializer_list<value_type> ilist) vector& operator=(std::initializer_list<value_type> ilist)
{ {
vector tmp(ilist.begin(), ilist.end()); vector tmp(ilist.begin(), ilist.end());
@ -117,141 +124,127 @@ public:
return *this; return *this;
} }
~vector() ~vector() // 析构函数
{ {
destroy_and_recover(begin_, end_, cap_ - begin_); destroy_and_recover(begin_, end_, cap_ - begin_);
begin_ = end_ = cap_ = nullptr; begin_ = end_ = cap_ = nullptr;
} }
public: public:
// 迭代器相关操作 // 迭代器相关操作
iterator begin() noexcept iterator begin() noexcept { return begin_; } // 返回开始迭代器
{ return begin_; } const_iterator begin() const noexcept { return begin_; } // 返回常量开始迭代器
const_iterator begin() const noexcept iterator end() noexcept { return end_; } // 返回结束迭代器
{ return begin_; } const_iterator end() const noexcept { return end_; } // 返回常量结束迭代器
iterator end() noexcept
{ return end_; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } // 返回反向开始迭代器
const_iterator end() const noexcept const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } // 返回常量反向开始迭代器
{ return end_; } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } // 返回反向结束迭代器
const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } // 返回常量反向结束迭代器
reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); } const_iterator cbegin() const noexcept { return begin(); } // 返回常量开始迭代器
const_reverse_iterator rbegin() const noexcept const_iterator cend() const noexcept { return end(); } // 返回常量结束迭代器
{ return const_reverse_iterator(end()); } const_reverse_iterator crbegin() const noexcept { return rbegin(); } // 返回常量反向开始迭代器
reverse_iterator rend() noexcept const_reverse_iterator crend() const noexcept { return rend(); } // 返回常量反向结束迭代器
{ return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept
{ return begin(); }
const_iterator cend() const noexcept
{ return end(); }
const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
const_reverse_iterator crend() const noexcept
{ return rend(); }
// 容量相关操作 // 容量相关操作
bool empty() const noexcept bool empty() const noexcept { return begin_ == end_; } // 检查容器是否为空
{ return begin_ == end_; } size_type size() const noexcept { return static_cast<size_type>(end_ - begin_); } // 返回容器大小
size_type size() const noexcept size_type max_size() const noexcept { return static_cast<size_type>(-1) / sizeof(T); } // 返回最大可能的容器大小
{ return static_cast<size_type>(end_ - begin_); } size_type capacity() const noexcept { return static_cast<size_type>(cap_ - begin_); } // 返回容器容量
size_type max_size() const noexcept void reserve(size_type n); // 预留空间
{ return static_cast<size_type>(-1) / sizeof(T); } void shrink_to_fit(); // 减小容量以适应大小
size_type capacity() const noexcept
{ return static_cast<size_type>(cap_ - begin_); }
void reserve(size_type n);
void shrink_to_fit();
// 访问元素相关操作 // 访问元素相关操作
reference operator[](size_type n) reference operator[](size_type n) // 访问第 n 个元素
{ {
MYSTL_DEBUG(n < size()); MYSTL_DEBUG(n < size());
return *(begin_ + n); return *(begin_ + n);
} }
const_reference operator[](size_type n) const const_reference operator[](size_type n) const // 访问第 n 个常量元素
{ {
MYSTL_DEBUG(n < size()); MYSTL_DEBUG(n < size());
return *(begin_ + n); return *(begin_ + n);
} }
reference at(size_type n) reference at(size_type n) // 访问第 n 个元素，带边界检查
{ {
THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range"); THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range");
return (*this)[n]; return (*this)[n];
} }
const_reference at(size_type n) const const_reference at(size_type n) const // 访问第 n 个常量元素，带边界检查
{ {
THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range"); THROW_OUT_OF_RANGE_IF(!(n < size()), "vector<T>::at() subscript out of range");
return (*this)[n]; return (*this)[n];
} }
reference front() reference front() // 访问第一个元素
{ {
MYSTL_DEBUG(!empty()); MYSTL_DEBUG(!empty());
return *begin_; return *begin_;
} }
const_reference front() const const_reference front() const // 访问第一个常量元素
{ {
MYSTL_DEBUG(!empty()); MYSTL_DEBUG(!empty());
return *begin_; return *begin_;
} }
reference back() reference back() // 访问最后一个元素
{ {
MYSTL_DEBUG(!empty()); MYSTL_DEBUG(!empty());
return *(end_ - 1); return *(end_ - 1);
} }
const_reference back() const const_reference back() const // 访问最后一个常量元素
{ {
MYSTL_DEBUG(!empty()); MYSTL_DEBUG(!empty());
return *(end_ - 1); return *(end_ - 1);
} }
pointer data() noexcept { return begin_; } pointer data() noexcept { return begin_; } // 返回数据指针
const_pointer data() const noexcept { return begin_; } const_pointer data() const noexcept { return begin_; } // 返回常量数据指针
// 修改容器相关操作 // 修改容器相关操作
// assign // assign
void assign(Iter first, Iter last) // 赋值指定迭代器范围内的元素
void assign(size_type n, const value_type& value)
{ fill_assign(n, value); }
template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0>
void assign(Iter first, Iter last)
{ {
MYSTL_DEBUG(!(last < first)); MYSTL_DEBUG(!(last < first));
copy_assign(first, last, iterator_category(first)); copy_assign(first, last, iterator_category(first));
} }
void assign(std::initializer_list<value_type> il) void assign(std::initializer_list<value_type> il) // 使用初始化列表赋值
{ copy_assign(il.begin(), il.end(), mystl::forward_iterator_tag{}); } {
copy_assign(il.begin(), il.end(), mystl::forward_iterator_tag{});
}
// emplace / emplace_back // emplace / emplace_back
template <class... Args> template <class... Args>
iterator emplace(const_iterator pos, Args&& ...args); iterator emplace(const_iterator pos, Args&& ...args) // 在指定位置就地构造元素
;
template <class... Args> template <class... Args>
void emplace_back(Args&& ...args); void emplace_back(Args&& ...args) // 在尾部就地构造元素
;
// push_back / pop_back // push_back / pop_back
void push_back(const value_type& value); void push_back(const value_type& value) // 在尾部添加元素
void push_back(value_type&& value) ;
{ emplace_back(mystl::move(value)); } void push_back(value_type&& value) // 在尾部添加移动构造的元素
{
emplace_back(mystl::move(value));
}
void pop_back(); void pop_back(); // 删除尾部元素
// insert // insert
iterator insert(const_iterator pos, const value_type& value); iterator insert(const_iterator pos, const value_type& value) // 在指定位置插入元素
iterator insert(const_iterator pos, value_type&& value) ;
{ return emplace(pos, mystl::move(value)); } iterator insert(const_iterator pos, value_type&& value) // 在指定位置插入移动构造的元素
{
return emplace(pos, mystl::move(value));
}
iterator insert(const_iterator pos, size_type n, const value_type& value) iterator insert(const_iterator pos, size_type n, const value_type& value) // 在指定位置插入指定数量的元素
{ {
MYSTL_DEBUG(pos >= begin() && pos <= end()); MYSTL_DEBUG(pos >= begin() && pos <= end());
return fill_insert(const_cast<iterator>(pos), n, value); return fill_insert(const_cast<iterator>(pos), n, value);
@ -259,185 +252,190 @@ public:
template <class Iter, typename std::enable_if< template <class Iter, typename std::enable_if<
mystl::is_input_iterator<Iter>::value, int>::type = 0> mystl::is_input_iterator<Iter>::value, int>::type = 0>
void insert(const_iterator pos, Iter first, Iter last) void insert(const_iterator pos, Iter first, Iter last) // 在指定位置插入迭代器范围内的元素
{ {
MYSTL_DEBUG(pos >= begin() && pos <= end() && !(last < first)); MYSTL_DEBUG(pos >= begin() && pos <= end() && !(last < first));
copy_insert(const_cast<iterator>(pos), first, last); copy_insert(const_cast<iterator>(pos), first, last);
} }
// erase / clear // erase / clear
iterator erase(const_iterator pos); iterator erase(const_iterator pos); // 删除指定位置的元素
iterator erase(const_iterator first, const_iterator last); iterator erase(const_iterator first, const_iterator last); // 删除指定范围内的元素
void clear() { erase(begin(), end()); } void clear() { erase(begin(), end()); } // 清空容器
// resize / reverse // resize / reverse
void resize(size_type new_size) { return resize(new_size, value_type()); } void resize(size_type new_size) { return resize(new_size, value_type()); } // 调整容器大小
void resize(size_type new_size, const value_type& value); void resize(size_type new_size, const value_type& value);
void reverse() { mystl::reverse(begin(), end()); } void reverse() { mystl::reverse(begin(), end()); } // 反转容器
// swap // swap
void swap(vector& rhs) noexcept; void swap(vector& rhs) noexcept; // 交换两个容器的内容
private: private:
// helper functions // helper functions
// initialize / destroy // initialize / destroy
void try_init() noexcept; void try_init() noexcept; // 尝试初始化，不抛出异常
void init_space(size_type size, size_type cap); void init_space(size_type size, size_type cap); // 初始化空间
void fill_init(size_type n, const value_type& value); void fill_init(size_type n, const value_type& value); // 使用指定值初始化空间
template <class Iter> template <class Iter>
void range_init(Iter first, Iter last); void range_init(Iter first, Iter last); // 使用迭代器范围初始化
void destroy_and_recover(iterator first, iterator last, size_type n); void destroy_and_recover(iterator first, iterator last, size_type n); // 销毁元素并回收空间
// calculate the growth size // calculate the growth size
size_type get_new_cap(size_type add_size); size_type get_new_cap(size_type add_size); // 计算新的容量大小
// assign // assign
void fill_assign(size_type n, const value_type& value); void fill_assign(size_type n, const value_type& value); // 使用指定值赋值
template <class IIter> template <class IIter>
void copy_assign(IIter first, IIter last, input_iterator_tag); void copy_assign(IIter first, IIter last, input_iterator_tag); // 复制赋值，输入迭代器
template <class FIter> template <class FIter>
void copy_assign(FIter first, FIter last, forward_iterator_tag); void copy_assign(FIter first, FIter last, forward_iterator_tag); // 复制赋值，前向迭代器
// reallocate // reallocate
template <class... Args> template <class... Args>
void reallocate_emplace(iterator pos, Args&& ...args); void reallocate_emplace(iterator pos, Args&& ...args); // 重新分配空间并在指定位置就地构造元素
void reallocate_insert(iterator pos, const value_type& value); void reallocate_insert(iterator pos, const value_type& value); // 重新分配空间并在指定位置插入元素
// insert // insert
iterator fill_insert(iterator pos, size_type n, const value_type& value); iterator fill_insert(iterator pos, size_type n, const value_type& value); // 在指定位置插入指定数量的元素
template <class IIter> template <class IIter>
void copy_insert(iterator pos, IIter first, IIter last); void copy_insert(iterator pos, IIter first, IIter last); // 在指定位置插入迭代器范围内的元素
// shrink_to_fit // shrink_to_fit
void reinsert(size_type size); void reinsert(size_type size); // 重新插入元素以减小容量
}; };
// 以下是 vector 类模板的成员函数实现，包括复制赋值操作符、移动赋值操作符、预留空间、减小容量、
// 在指定位置就地构造元素、在尾部就地构造元素、在尾部插入元素、弹出尾部元素、在指定位置插入元素、
// 删除指定位置的元素、删除指定范围内的元素、调整容器大小、与另一个 vector 交换内容等函数的实现。
// 重载比较操作符，实现 vector 与其他 vector 之间的比较
/*****************************************************************************************/ /*****************************************************************************************/
// 复制赋值操作符 // 复制赋值操作符，用于将一个 vector 的内容赋值给另一个 vector
template <class T> template <class T>
vector<T>& vector<T>::operator=(const vector& rhs) vector<T>& vector<T>::operator=(const vector& rhs)
{ {
if (this != &rhs) if (this != &rhs) // 检查自赋值
{ {
const auto len = rhs.size(); const auto len = rhs.size(); // 获取右边 vector 的大小
if (len > capacity()) if (len > capacity()) // 如果右边 vector 的大小大于当前 vector 的容量
{ {
vector tmp(rhs.begin(), rhs.end()); vector tmp(rhs.begin(), rhs.end()); // 创建一个临时 vector 用于交换
swap(tmp); swap(tmp); // 交换当前 vector 和临时 vector 的内容
} }
else if (size() >= len) else if (size() >= len) // 如果当前 vector 的大小大于或等于右边 vector 的大小
{ {
auto i = mystl::copy(rhs.begin(), rhs.end(), begin()); auto i = mystl::copy(rhs.begin(), rhs.end(), begin()); // 复制元素
data_allocator::destroy(i, end_); data_allocator::destroy(i, end_); // 销毁多余的元素
end_ = begin_ + len; end_ = begin_ + len; // 更新 end_ 指针
} }
else else // 如果当前 vector 的大小小于右边 vector 的大小
{ {
mystl::copy(rhs.begin(), rhs.begin() + size(), begin_); mystl::copy(rhs.begin(), rhs.begin() + size(), begin_); // 复制已有元素
mystl::uninitialized_copy(rhs.begin() + size(), rhs.end(), end_); mystl::uninitialized_copy(rhs.begin() + size(), rhs.end(), end_); // 复制剩余元素到未初始化的内存
cap_ = end_ = begin_ + len; cap_ = end_ = begin_ + len; // 更新 end_ 和 cap_ 指针
} }
} }
return *this; return *this; // 返回当前 vector 的引用
} }
// 移动赋值操作符 // 移动赋值操作符，用于将一个 vector 的内容移动到另一个 vector
template <class T> template <class T>
vector<T>& vector<T>::operator=(vector&& rhs) noexcept vector<T>& vector<T>::operator=(vector&& rhs) noexcept
{ {
destroy_and_recover(begin_, end_, cap_ - begin_); destroy_and_recover(begin_, end_, cap_ - begin_); // 销毁当前 vector 的元素并回收内存
begin_ = rhs.begin_; begin_ = rhs.begin_; // 移动右边 vector 的开始指针
end_ = rhs.end_; end_ = rhs.end_; // 移动右边 vector 的结束指针
cap_ = rhs.cap_; cap_ = rhs.cap_; // 移动右边 vector 的容量指针
rhs.begin_ = nullptr; rhs.begin_ = nullptr; // 将右边 vector 的指针设置为 nullptr
rhs.end_ = nullptr; rhs.end_ = nullptr; // 将右边 vector 的指针设置为 nullptr
rhs.cap_ = nullptr; rhs.cap_ = nullptr; // 将右边 vector 的指针设置为 nullptr
return *this; return *this; // 返回当前 vector 的引用
} }
// 预留空间大小，当原容量小于要求大小时，才会重新分配 // 预留空间大小，如果当前容量小于要求的大小，则会重新分配内存
template <class T> template <class T>
void vector<T>::reserve(size_type n) void vector<T>::reserve(size_type n)
{ {
if (capacity() < n) if (capacity() < n) // 如果当前容量小于要求的大小
{ {
THROW_LENGTH_ERROR_IF(n > max_size(), THROW_LENGTH_ERROR_IF(n > max_size(), // 如果要求的大小超过最大可能大小，则抛出异常
"n can not larger than max_size() in vector<T>::reserve(n)"); "n can not larger than max_size() in vector<T>::reserve(n)");
const auto old_size = size(); const auto old_size = size(); // 获取当前 vector 的大小
auto tmp = data_allocator::allocate(n); auto tmp = data_allocator::allocate(n); // 分配新的内存
mystl::uninitialized_move(begin_, end_, tmp); mystl::uninitialized_move(begin_, end_, tmp); // 将元素移动到新的内存
data_allocator::deallocate(begin_, cap_ - begin_); data_allocator::deallocate(begin_, cap_ - begin_); // 回收旧内存
begin_ = tmp; begin_ = tmp; // 更新开始指针
end_ = tmp + old_size; end_ = tmp + old_size; // 更新结束指针
cap_ = begin_ + n; cap_ = begin_ + n; // 更新容量指针
} }
} }
// 放弃多余的容量 // 放弃多余的容量，如果当前 vector 的大小小于容量，则会重新分配内存以减少容量
template <class T> template <class T>
void vector<T>::shrink_to_fit() void vector<T>::shrink_to_fit()
{ {
if (end_ < cap_) if (end_ < cap_) // 如果当前 vector 的大小小于容量
{ {
reinsert(size()); reinsert(size()); // 重新插入元素以减小容量
} }
} }
// 在 pos 位置就地构造元素，避免额外的复制或移动开销 // 在指定位置就地构造元素，使用emplace操作避免额外的复制或移动开销
template <class T> template <class T>
template <class ...Args> template <class ...Args>
typename vector<T>::iterator typename vector<T>::iterator
vector<T>::emplace(const_iterator pos, Args&& ...args) vector<T>::emplace(const_iterator pos, Args&& ...args)
{ {
MYSTL_DEBUG(pos >= begin() && pos <= end()); MYSTL_DEBUG(pos >= begin() && pos <= end()); // 确保位置有效
iterator xpos = const_cast<iterator>(pos); iterator xpos = const_cast<iterator>(pos); // 将 const_iterator 转换为 iterator
const size_type n = xpos - begin_; const size_type n = xpos - begin_; // 计算位置偏移
if (end_ != cap_ && xpos == end_) if (end_ != cap_ && xpos == end_) // 如果位置在 vector 末尾且还有剩余容量
{ {
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...); data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...); // 就地构造元素
++end_; ++end_; // 更新结束指针
} }
else if (end_ != cap_) else if (end_ != cap_) // 如果位置不在 vector 末尾但还有剩余容量
{ {
auto new_end = end_; auto new_end = end_; // 保存当前结束指针
data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); // 就地构造元素
++new_end; ++new_end; // 更新新结束指针
mystl::copy_backward(xpos, end_ - 1, end_); mystl::copy_backward(xpos, end_ - 1, end_); // 向后复制元素
*xpos = value_type(mystl::forward<Args>(args)...); *xpos = value_type(mystl::forward<Args>(args)...); // 就地构造元素
end_ = new_end; end_ = new_end; // 更新结束指针
} }
else else // 如果没有剩余容量
{ {
reallocate_emplace(xpos, mystl::forward<Args>(args)...); reallocate_emplace(xpos, mystl::forward<Args>(args)...); // 重新分配内存并就地构造元素
} }
return begin() + n; return begin() + n; // 返回插入位置的迭代器
} }
// 在尾部就地构造元素，避免额外的复制或移动开销 // 在尾部就地构造元素，使用emplace_back操作避免额外的复制或移动开销
template <class T> template <class T>
template <class ...Args> template <class ...Args>
void vector<T>::emplace_back(Args&& ...args) void vector<T>::emplace_back(Args&& ...args)
{ {
if (end_ < cap_) if (end_ < cap_) // 如果还有剩余容量
{ {
data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...); data_allocator::construct(mystl::address_of(*end_), mystl::forward<Args>(args)...); // 就地构造元素
++end_; ++end_; // 更新结束指针
} }
else else // 如果没有剩余容量
{ {
reallocate_emplace(end_, mystl::forward<Args>(args)...); reallocate_emplace(end_, mystl::forward<Args>(args)...); // 重新分配内存并就地构造元素
} }
} }
@ -445,14 +443,14 @@ void vector<T>::emplace_back(Args&& ...args)
template <class T> template <class T>
void vector<T>::push_back(const value_type& value) void vector<T>::push_back(const value_type& value)
{ {
if (end_ != cap_) if (end_ != cap_) // 如果还有剩余容量
{ {
data_allocator::construct(mystl::address_of(*end_), value); data_allocator::construct(mystl::address_of(*end_), value); // 构造元素
++end_; ++end_; // 更新结束指针
} }
else else // 如果没有剩余容量
{ {
reallocate_insert(end_, value); reallocate_insert(end_, value); // 重新分配内存并插入元素
} }
} }
@ -460,65 +458,39 @@ void vector<T>::push_back(const value_type& value)
template <class T> template <class T>
void vector<T>::pop_back() void vector<T>::pop_back()
{ {
MYSTL_DEBUG(!empty()); MYSTL_DEBUG(!empty()); // 确保 vector 不为空
data_allocator::destroy(end_ - 1); data_allocator::destroy(end_ - 1); // 销毁尾部元素
--end_; --end_; // 更新结束指针
} }
// 在 pos 处插入元素 // 在指定位置插入元素
template <class T> template <class T>
typename vector<T>::iterator typename vector<T>::iterator
vector<T>::insert(const_iterator pos, const value_type& value) vector<T>::insert(const_iterator pos, const value_type& value)
{ {
MYSTL_DEBUG(pos >= begin() && pos <= end()); MYSTL_DEBUG(pos >= begin() && pos <= end()); // 确保位置有效
iterator xpos = const_cast<iterator>(pos); iterator xpos = const_cast<iterator>(pos); // 将 const_iterator 转换为 iterator
const size_type n = pos - begin_; const size_type n = pos - begin_; // 计算位置偏移
if (end_ != cap_ && xpos == end_) if (end_ != cap_ && xpos == end_) // 如果位置在 vector 末尾且还有剩余容量
{
data_allocator::construct(mystl::address_of(*end_), value);
++end_;
}
else if (end_ != cap_)
{ {
auto new_end = end_; data_allocator::construct(mystl::address_of(*end_), value); // 构造元素
data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); ++end_; // 更新结束指针
++new_end;
auto value_copy = value; // 避免元素因以下复制操作而被改变
mystl::copy_backward(xpos, end_ - 1, end_);
*xpos = mystl::move(value_copy);
end_ = new_end;
} }
else else if (end_ != cap_) // 如果位置不在 vector 末尾但还有剩余容量
{ {
reallocate_insert(xpos, value); auto new_end = end_; // 保存当前结束指针
data_allocator::construct(mystl::address_of(*end_), *(end_ - 1)); // 就地构造元素
++new_end; // 更新新结束指针
auto value_copy = value; // 保存值以防复制改变原始值
mystl::copy_backward(xpos, end_ - 1, end_); // 向后复制元素
*xpos = mystl::move(value_copy); // 移动构造元素
end_ = new_end; // 更新结束指针
} }
return begin_ + n; else // 如果没有剩余容量
}
// 删除 pos 位置上的元素
template <class T>
typename vector<T>::iterator
vector<T>::erase(const_iterator pos)
{ {
MYSTL_DEBUG(pos >= begin() && pos < end()); reallocate_insert(xpos, value); // 重新分配内存并插入元素
iterator xpos = begin_ + (pos - begin());
mystl::move(xpos + 1, end_, xpos);
data_allocator::destroy(end_ - 1);
--end_;
return xpos;
} }
return begin_ + n; // 返回插入位置的迭代器
// 删除[first, last)上的元素
template <class T>
typename vector<T>::iterator
vector<T>::erase(const_iterator first, const_iterator last)
{
MYSTL_DEBUG(first >= begin() && last <= end() && !(last < first));
const auto n = first - begin();
iterator r = begin_ + (first - begin());
data_allocator::destroy(mystl::move(r + (last - first), end_, r), end_);
end_ = end_ - (last - first);
return begin_ + n;
} }
// 重置容器大小 // 重置容器大小
@ -548,126 +520,7 @@ void vector<T>::swap(vector<T>& rhs) noexcept
} }
/*****************************************************************************************/ /*****************************************************************************************/
// helper function
// try_init 函数，若分配失败则忽略，不抛出异常
template <class T>
void vector<T>::try_init() noexcept
{
try
{
begin_ = data_allocator::allocate(16);
end_ = begin_;
cap_ = begin_ + 16;
}
catch (...)
{
begin_ = nullptr;
end_ = nullptr;
cap_ = nullptr;
}
}
// init_space 函数
template <class T>
void vector<T>::init_space(size_type size, size_type cap)
{
try
{
begin_ = data_allocator::allocate(cap);
end_ = begin_ + size;
cap_ = begin_ + cap;
}
catch (...)
{
begin_ = nullptr;
end_ = nullptr;
cap_ = nullptr;
throw;
}
}
// fill_init 函数
template <class T>
void vector<T>::
fill_init(size_type n, const value_type& value)
{
const size_type init_size = mystl::max(static_cast<size_type>(16), n);
init_space(n, init_size);
mystl::uninitialized_fill_n(begin_, n, value);
}
// range_init 函数
template <class T>
template <class Iter>
void vector<T>::
range_init(Iter first, Iter last)
{
const size_type len = mystl::distance(first, last);
const size_type init_size = mystl::max(len, static_cast<size_type>(16));
init_space(len, init_size);
mystl::uninitialized_copy(first, last, begin_);
}
// destroy_and_recover 函数
template <class T>
void vector<T>::
destroy_and_recover(iterator first, iterator last, size_type n)
{
data_allocator::destroy(first, last);
data_allocator::deallocate(first, n);
}
// get_new_cap 函数
template <class T>
typename vector<T>::size_type
vector<T>::
get_new_cap(size_type add_size)
{
const auto old_size = capacity();
THROW_LENGTH_ERROR_IF(old_size > max_size() - add_size,
"vector<T>'s size too big");
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;
}
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>::
fill_assign(size_type n, const value_type& value)
{
if (n > capacity())
{
vector tmp(n, value);
swap(tmp);
}
else if (n > size())
{
mystl::fill(begin(), end(), value);
end_ = mystl::uninitialized_fill_n(end_, n - size(), value);
}
else
{
erase(mystl::fill_n(begin_, n, value), end_);
}
}
// copy_assign 函数
template <class T>
template <class IIter>
void vector<T>::
copy_assign(IIter first, IIter last, input_iterator_tag)
{
auto cur = begin_;
for (; first != last && cur != end_; ++first, ++cur)
{
*cur = *first; *cur = *first;
} }
if (first == last) if (first == last)
@ -863,74 +716,79 @@ copy_insert(iterator pos, IIter first, IIter last)
cap_ = begin_ + new_size; cap_ = begin_ + new_size;
} }
} }
// reinsert 函数，用于重新分配内存空间并将现有元素移动到新的内存空间
// reinsert 函数 // 通常在减小 vector 容量时被调用，以释放多余的内存
template <class T> template <class T>
void vector<T>::reinsert(size_type size) void vector<T>::reinsert(size_type size)
{ {
auto new_begin = data_allocator::allocate(size); auto new_begin = data_allocator::allocate(size); // 分配新的内存空间，大小为 size
try try
{ {
mystl::uninitialized_move(begin_, end_, new_begin); mystl::uninitialized_move(begin_, end_, new_begin); // 将 [begin_, end_) 范围内的元素移动到新内存空间
} }
catch (...) catch (...) // 如果在移动过程中发生异常，则释放新分配的内存并重新抛出异常
{ {
data_allocator::deallocate(new_begin, size); data_allocator::deallocate(new_begin, size);
throw; throw;
} }
data_allocator::deallocate(begin_, cap_ - begin_); data_allocator::deallocate(begin_, cap_ - begin_); // 释放旧的内存空间
begin_ = new_begin; begin_ = new_begin; // 更新 begin_ 指针到新内存空间
end_ = begin_ + size; end_ = begin_ + size; // 更新 end_ 指针到新内存空间的末尾
cap_ = begin_ + size; cap_ = begin_ + size; // 更新 cap_ 指针到新内存空间的末尾
} }
/*****************************************************************************************/ /*********************************************************************************************/
// 重载比较操作符 // 重载比较操作符，提供 vector 与其他 vector 之间的比较功能
// 等于比较操作符，检查两个 vector 是否相等
template <class T> template <class T>
bool operator==(const vector<T>& lhs, const vector<T>& rhs) bool operator==(const vector<T>& lhs, const vector<T>& rhs)
{ {
return lhs.size() == rhs.size() && return lhs.size() == rhs.size() && // 如果两个 vector 的大小相等
mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); // 并且每个对应元素都相等，则返回 true
} }
// 小于比较操作符，进行字典序比较
template <class T> template <class T>
bool operator<(const vector<T>& lhs, const vector<T>& rhs) bool operator<(const vector<T>& lhs, const vector<T>& rhs)
{ {
return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); return mystl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); // 返回 lhs 是否字典序小于 rhs
} }
// 不等于比较操作符，检查两个 vector 是否不相等
template <class T> template <class T>
bool operator!=(const vector<T>& lhs, const vector<T>& rhs) bool operator!=(const vector<T>& lhs, const vector<T>& rhs)
{ {
return !(lhs == rhs); return !(lhs == rhs); // 如果两个 vector 不相等，则返回 true
} }
// 大于比较操作符，检查 lhs 是否大于 rhs
template <class T> template <class T>
bool operator>(const vector<T>& lhs, const vector<T>& rhs) bool operator>(const vector<T>& lhs, const vector<T>& rhs)
{ {
return rhs < lhs; return rhs < lhs; // 如果 rhs 小于 lhs，则返回 true
} }
// 小于等于比较操作符，检查 lhs 是否小于等于 rhs
template <class T> template <class T>
bool operator<=(const vector<T>& lhs, const vector<T>& rhs) bool operator<=(const vector<T>& lhs, const vector<T>& rhs)
{ {
return !(rhs < lhs); return !(rhs < lhs); // 如果 rhs 不小于 lhs，则返回 true
} }
// 大于等于比较操作符，检查 lhs 是否大于等于 rhs
template <class T> template <class T>
bool operator>=(const vector<T>& lhs, const vector<T>& rhs) bool operator>=(const vector<T>& lhs, const vector<T>& rhs)
{ {
return !(lhs < rhs); return !(lhs < rhs); // 如果 lhs 不小于 rhs，则返回 true
} }
// 重载 mystl 的 swap // 重载 mystl 的 swap 函数，用于交换两个 vector 的内容
template <class T> template <class T>
void swap(vector<T>& lhs, vector<T>& rhs) void swap(vector<T>& lhs, vector<T>& rhs)
{ {
lhs.swap(rhs); lhs.swap(rhs); // 调用 vector 的 swap 方法交换两个 vector 的内容
} }
} // namespace mystl } // namespace mystl // 结束 mystl 命名空间
#endif // !MYTINYSTL_VECTOR_H_ #endif // !MYTINYSTL_VECTOR_H_ // 结束头文件保护宏定义
Write Preview
Loading…
Cancel
Save