diff --git a/src/MyTinySTL-master/MyTinySTL/deque.h b/src/MyTinySTL-master/MyTinySTL/deque.h index 7975d83..9e7dca7 100644 --- a/src/MyTinySTL-master/MyTinySTL/deque.h +++ b/src/MyTinySTL-master/MyTinySTL/deque.h @@ -1,5 +1,5 @@ -#ifndef MYTINYSTL_DEQUE_H_ -#define MYTINYSTL_DEQUE_H_ +#ifndef MYTINYSTL_DEQUE_H_ // 如果没有定义 MYTINYSTL_DEQUE_H_ +#define MYTINYSTL_DEQUE_H_ // 定义 MYTINYSTL_DEQUE_H_，防止头文件重复包含 // 这个头文件包含了一个模板类 deque // deque: 双端队列 @@ -15,467 +15,592 @@ // * push_back // * insert -#include +#include // 包含 initializer_list 头文件，用于支持初始化列表 -#include "iterator.h" -#include "memory.h" -#include "util.h" -#include "exceptdef.h" +#include "iterator.h" // 包含自定义的迭代器头文件 +#include "memory.h" // 包含自定义的内存管理头文件 +#include "util.h" // 包含自定义的工具函数头文件 +#include "exceptdef.h" // 包含自定义的异常定义头文件 -namespace mystl +namespace mystl // 定义 mystl 命名空间 { -#ifdef max -#pragma message("#undefing marco max") -#undef max + // 如果定义了宏 max，取消其定义 +#ifdef max +#pragma message("#undefing marco max") // 输出提示信息 +#undef max #endif // max -#ifdef min -#pragma message("#undefing marco min") -#undef min +// 如果定义了宏 min，取消其定义 +#ifdef min +#pragma message("#undefing marco min") // 输出提示信息 +#undef min #endif // min -// deque map 初始化的大小 +// 定义 deque map 初始化的大小，默认为 8 #ifndef DEQUE_MAP_INIT_SIZE #define DEQUE_MAP_INIT_SIZE 8 #endif -template -struct deque_buf_size -{ - static constexpr size_t value = sizeof(T) < 256 ? 4096 / sizeof(T) : 16; -}; - -// deque 的迭代器设计 -template -struct deque_iterator : public iterator -{ - typedef deque_iterator iterator; - typedef deque_iterator const_iterator; - typedef deque_iterator self; - - typedef T value_type; - typedef Ptr pointer; - typedef Ref reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef T* value_pointer; - typedef T** map_pointer; - - static const size_type buffer_size = deque_buf_size::value; - - // 迭代器所含成员数据 - value_pointer cur; // 指向所在缓冲区的当前元素 - value_pointer first; // 指向所在缓冲区的头部 - value_pointer last; // 指向所在缓冲区的尾部 - map_pointer node; // 缓冲区所在节点 - - // 构造、复制、移动函数 - deque_iterator() noexcept - :cur(nullptr), first(nullptr), last(nullptr), node(nullptr) {} - - deque_iterator(value_pointer v, map_pointer n) - :cur(v), first(*n), last(*n + buffer_size), node(n) {} - - deque_iterator(const iterator& rhs) - :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) - { - } - deque_iterator(iterator&& rhs) noexcept - :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) - { - rhs.cur = nullptr; - rhs.first = nullptr; - rhs.last = nullptr; - rhs.node = nullptr; - } - - deque_iterator(const const_iterator& rhs) - :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) - { - } - - self& operator=(const iterator& rhs) - { - if (this != &rhs) +// 定义 deque_buf_size 结构体，用于计算每个缓冲区的大小 + template + struct deque_buf_size { - cur = rhs.cur; - first = rhs.first; - last = rhs.last; - node = rhs.node; - } - return *this; - } - - // 转到另一个缓冲区 - void set_node(map_pointer new_node) - { - node = new_node; - first = *new_node; - last = first + buffer_size; - } - - // 重载运算符 - reference operator*() const { return *cur; } - pointer operator->() const { return cur; } - - difference_type operator-(const self& x) const - { - return static_cast(buffer_size) * (node - x.node) - + (cur - first) - (x.cur - x.first); - } - - self& operator++() - { - ++cur; - if (cur == last) - { // 如果到达缓冲区的尾 - set_node(node + 1); - cur = first; - } - return *this; - } - self operator++(int) - { - self tmp = *this; - ++*this; - return tmp; - } - - self& operator--() - { - if (cur == first) - { // 如果到达缓冲区的头 - set_node(node - 1); - cur = last; - } - --cur; - return *this; - } - self operator--(int) - { - self tmp = *this; - --*this; - return tmp; - } - - self& operator+=(difference_type n) - { - const auto offset = n + (cur - first); - if (offset >= 0 && offset < static_cast(buffer_size)) - { // 仍在当前缓冲区 - cur += n; - } - else - { // 要跳到其他的缓冲区 - const auto node_offset = offset > 0 - ? offset / static_cast(buffer_size) - : -static_cast((-offset - 1) / buffer_size) - 1; - set_node(node + node_offset); - cur = first + (offset - node_offset * static_cast(buffer_size)); - } - return *this; - } - self operator+(difference_type n) const - { - self tmp = *this; - return tmp += n; - } - self& operator-=(difference_type n) - { - return *this += -n; - } - self operator-(difference_type n) const - { - self tmp = *this; - return tmp -= n; - } - - reference operator[](difference_type n) const { return *(*this + n); } - - // 重载比较操作符 - bool operator==(const self& rhs) const { return cur == rhs.cur; } - bool operator< (const self& rhs) const - { return node == rhs.node ? (cur < rhs.cur) : (node < rhs.node); } - bool operator!=(const self& rhs) const { return !(*this == rhs); } - bool operator> (const self& rhs) const { return rhs < *this; } - bool operator<=(const self& rhs) const { return !(rhs < *this); } - bool operator>=(const self& rhs) const { return !(*this < rhs); } -}; + static constexpr size_t value = sizeof(T) < 256 ? 4096 / sizeof(T) : 16; // 计算缓冲区大小 + }; -// 模板类 deque + // 定义 deque 的迭代器 + template + struct deque_iterator : public iterator // 继承自 iterator + { + typedef deque_iterator iterator; // 定义迭代器类型 + typedef deque_iterator const_iterator; // 定义常量迭代器类型 + typedef deque_iterator self; // 定义自身类型 + + typedef T value_type; // 定义值类型 + typedef Ptr pointer; // 定义指针类型 + typedef Ref reference; // 定义引用类型 + typedef size_t size_type; // 定义大小类型 + typedef ptrdiff_t difference_type; // 定义差值类型 + typedef T* value_pointer; // 定义值指针类型 + typedef T** map_pointer; // 定义映射指针类型 + + static const size_type buffer_size = deque_buf_size::value; // 缓冲区大小 + + // 迭代器所含成员数据 + value_pointer cur; // 指向所在缓冲区的当前元素 + value_pointer first; // 指向所在缓冲区的头部 + value_pointer last; // 指向所在缓冲区的尾部 + map_pointer node; // 缓冲区所在节点 + + // 构造、复制、移动函数 + deque_iterator() noexcept // 默认构造函数 + :cur(nullptr), first(nullptr), last(nullptr), node(nullptr) {} + + deque_iterator(value_pointer v, map_pointer n) // 构造函数 + :cur(v), first(*n), last(*n + buffer_size), node(n) {} + + deque_iterator(const iterator& rhs) // 复制构造函数 + :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) + { + } + deque_iterator(iterator&& rhs) noexcept // 移动构造函数 + :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) + { + rhs.cur = nullptr; + rhs.first = nullptr; + rhs.last = nullptr; + rhs.node = nullptr; + } + + deque_iterator(const const_iterator& rhs) // 从常量迭代器构造 + :cur(rhs.cur), first(rhs.first), last(rhs.last), node(rhs.node) + { + } + + self& operator=(const iterator& rhs) // 复制赋值运算符 + { + if (this != &rhs) + { + cur = rhs.cur; + first = rhs.first; + last = rhs.last; + node = rhs.node; + } + return *this; + } + + // 转到另一个缓冲区 + void set_node(map_pointer new_node) // 设置节点 + { + node = new_node; + first = *new_node; + last = first + buffer_size; + } + + // 重载运算符 + reference operator*() const { return *cur; } // 解引用运算符 + pointer operator->() const { return cur; } // 指针运算符 + + difference_type operator-(const self& x) const // 迭代器减法运算符 + { + return static_cast(buffer_size) * (node - x.node) + + (cur - first) - (x.cur - x.first); + } + + self& operator++() // 前置递增运算符 + { + ++cur; + if (cur == last) // 如果到达缓冲区的尾部 + { + set_node(node + 1); // 转到下一个缓冲区 + cur = first; // 设置当前元素为新缓冲区的头部 + } + return *this; + } + self operator++(int) // 后置递增运算符 + { + self tmp = *this; + ++*this; + return tmp; + } + + self& operator--() // 前置递减运算符 + { + if (cur == first) // 如果到达缓冲区的头部 + { + set_node(node - 1); // 转到前一个缓冲区 + cur = last; // 设置当前元素为新缓冲区的尾部 + } + --cur; + return *this; + } + self operator--(int) // 后置递减运算符 + { + self tmp = *this; + --*this; + return tmp; + } + + self& operator+=(difference_type n) // 迭代器加法赋值运算符 + { + const auto offset = n + (cur - first); + if (offset >= 0 && offset < static_cast(buffer_size)) + { // 仍在当前缓冲区 + cur += n; + } + else + { // 需要跳到其他缓冲区 + const auto node_offset = offset > 0 + ? offset / static_cast(buffer_size) + : -static_cast((-offset - 1) / buffer_size) - 1; + set_node(node + node_offset); + cur = first + (offset - node_offset * static_cast(buffer_size)); + } + return *this; + } + self operator+(difference_type n) const // 迭代器加法运算符 + { + self tmp = *this; + return tmp += n; + } + self& operator-=(difference_type n) // 迭代器减法赋值运算符 + { + return *this += -n; + } + self operator-(difference_type n) const // 迭代器减法运算符 + { + self tmp = *this; + return tmp -= n; + } + + reference operator[](difference_type n) const { return *(*this + n); } // 下标运算符 + + // 重载比较操作符 + bool operator==(const self& rhs) const { return cur == rhs.cur; } // 等于运算符 + bool operator< (const self& rhs) const // 小于运算符 + { + return node == rhs.node ? (cur < rhs.cur) : (node < rhs.node); + } + bool operator!=(const self& rhs) const { return !(*this == rhs); } // 不等于运算符 + bool operator> (const self& rhs) const { return rhs < *this; } // 大于运算符 + bool operator<=(const self& rhs) const { return !(rhs < *this); } // 小于等于运算符 + bool operator>=(const self& rhs) const { return !(*this < rhs); } // 大于等于运算符 + }; + // 模板类 deque // 模板参数代表数据类型 -template -class deque -{ -public: - // deque 的型别定义 - typedef mystl::allocator allocator_type; - typedef mystl::allocator data_allocator; - typedef mystl::allocator map_allocator; - - typedef typename allocator_type::value_type value_type; - typedef typename allocator_type::pointer pointer; - typedef typename allocator_type::const_pointer const_pointer; - typedef typename allocator_type::reference reference; - typedef typename allocator_type::const_reference const_reference; - typedef typename allocator_type::size_type size_type; - typedef typename allocator_type::difference_type difference_type; - typedef pointer* map_pointer; - typedef const_pointer* const_map_pointer; - - typedef deque_iterator iterator; - typedef deque_iterator const_iterator; - typedef mystl::reverse_iterator reverse_iterator; - typedef mystl::reverse_iterator const_reverse_iterator; - - allocator_type get_allocator() { return allocator_type(); } - - static const size_type buffer_size = deque_buf_size::value; + template + class deque + { + public: + // deque 的型别定义 + typedef mystl::allocator allocator_type; // 定义分配器类型 + typedef mystl::allocator data_allocator; // 定义数据分配器类型 + typedef mystl::allocator map_allocator; // 定义映射分配器类型 + + typedef typename allocator_type::value_type value_type; // 定义值类型 + typedef typename allocator_type::pointer pointer; // 定义指针类型 + typedef typename allocator_type::const_pointer const_pointer; // 定义常量指针类型 + typedef typename allocator_type::reference reference; // 定义引用类型 + typedef typename allocator_type::const_reference const_reference; // 定义常量引用类型 + typedef typename allocator_type::size_type size_type; // 定义大小类型 + typedef typename allocator_type::difference_type difference_type; // 定义差值类型 + typedef pointer* map_pointer; // 定义映射指针类型 + typedef const_pointer* const_map_pointer; // 定义常量映射指针类型 + + typedef deque_iterator iterator; // 定义迭代器类型 + typedef deque_iterator const_iterator; // 定义常量迭代器类型 + typedef mystl::reverse_iterator reverse_iterator; // 定义反向迭代器类型 + typedef mystl::reverse_iterator const_reverse_iterator; // 定义常量反向迭代器类型 + + allocator_type get_allocator() { return allocator_type(); } // 获取分配器 + + static const size_type buffer_size = deque_buf_size::value; // 缓冲区大小 + + private: + // 用以下四个数据来表现一个 deque + iterator begin_; // 指向第一个节点 + iterator end_; // 指向最后一个结点 + map_pointer map_; // 指向一块 map，map 中的每个元素都是一个指针，指向一个缓冲区 + size_type map_size_; // map 内指针的数目 + + public: + // 构造、复制、移动、析构函数 + + // 默认构造函数，初始化为空 + deque() + { + fill_init(0, value_type()); + } + + // 显式构造函数，指定大小并初始化为默认值 + explicit deque(size_type n) + { + fill_init(n, value_type()); + } + + // 构造函数，指定大小和值 + deque(size_type n, const value_type& value) + { + fill_init(n, value); + } + + // 模板构造函数，从输入迭代器初始化 + template ::value, int>::type = 0> + deque(IIter first, IIter last) + { + copy_init(first, last, iterator_category(first)); + } + + // 从初始化列表初始化 + deque(std::initializer_list ilist) + { + copy_init(ilist.begin(), ilist.end(), mystl::forward_iterator_tag()); + } + + // 拷贝构造函数 + deque(const deque& rhs) + { + copy_init(rhs.begin(), rhs.end(), mystl::forward_iterator_tag()); + } + + // 移动构造函数 + deque(deque&& rhs) noexcept + :begin_(mystl::move(rhs.begin_)), + end_(mystl::move(rhs.end_)), + map_(rhs.map_), + map_size_(rhs.map_size_) + { + rhs.map_ = nullptr; + rhs.map_size_ = 0; + } + + // 拷贝赋值运算符 + deque& operator=(const deque& rhs); + + // 移动赋值运算符 + deque& operator=(deque&& rhs); + + // 从初始化列表赋值 + deque& operator=(std::initializer_list ilist) + { + deque tmp(ilist); + swap(tmp); + return *this; + } + + // 析构函数 + ~deque() + { + if (map_ != nullptr) + { + clear(); + data_allocator::deallocate(*begin_.node, buffer_size); + *begin_.node = nullptr; + map_allocator::deallocate(map_, map_size_); + map_ = nullptr; + } + } + + public: + // 迭代器相关操作 + + // 获取开始迭代器 + iterator begin() noexcept + { + return begin_; + } + // 获取开始常量迭代器 + const_iterator begin() const noexcept + { + return begin_; + } + // 获取结束迭代器 + iterator end() noexcept + { + return end_; + } + // 获取结束常量迭代器 + const_iterator end() const noexcept + { + return end_; + } + + // 获取反向开始迭代器 + reverse_iterator rbegin() noexcept + { + return reverse_iterator(end()); + } + // 获取反向开始常量迭代器 + const_reverse_iterator rbegin() const noexcept + { + return reverse_iterator(end()); + } + // 获取反向结束迭代器 + reverse_iterator rend() noexcept + { + return reverse_iterator(begin()); + } + // 获取反向结束常量迭代器 + const_reverse_iterator rend() const noexcept + { + return 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 { return begin() == end(); } + // 获取大小 + size_type size() const noexcept { return end_ - begin_; } + // 获取最大可能大小 + size_type max_size() const noexcept { return static_cast(-1); } + // 重置大小 + void resize(size_type new_size) { resize(new_size, value_type()); } + // 重置大小并填充 + void resize(size_type new_size, const value_type& value); + // 减小容量以适应大小 + void shrink_to_fit() noexcept; + + // 访问元素相关操作 + + // 下标运算符 + reference operator[](size_type n) + { + MYSTL_DEBUG(n < size()); + return begin_[n]; + } + // 常量下标运算符 + const_reference operator[](size_type n) const + { + MYSTL_DEBUG(n < size()); + return begin_[n]; + } + + // at 函数 + reference at(size_type n) + { + THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); + return (*this)[n]; + } + // 常量 at 函数 + const_reference at(size_type n) const + { + THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); + return (*this)[n]; + } + + // 获取第一个元素 + reference front() + { + MYSTL_DEBUG(!empty()); + return *begin(); + } + // 获取第一个常量元素 + const_reference front() const + { + MYSTL_DEBUG(!empty()); + return *begin(); + } + // 获取最后一个元素 + reference back() + { + MYSTL_DEBUG(!empty()); + return *(end() - 1); + } + // 获取最后一个常量元素 + const_reference back() const + { + MYSTL_DEBUG(!empty()); + return *(end() - 1); + } + // 修改容器相关操作 + +// assign 函数：分配 n 个元素并赋值 + void assign(size_type n, const value_type& value) + { + fill_assign(n, value); + } // 调用 fill_assign 函数 + +// assign 函数：从输入迭代器分配元素 + template ::value, int>::type = 0> + void assign(IIter first, IIter last) + { + copy_assign(first, last, iterator_category(first)); + } // 调用 copy_assign 函数 + +// assign 函数：从初始化列表分配元素 + void assign(std::initializer_list ilist) + { + copy_assign(ilist.begin(), ilist.end(), mystl::forward_iterator_tag{}); + } // 调用 copy_assign 函数 + +// emplace_front 函数：在头部就地构建元素 + template + void emplace_front(Args&& ...args); + + // emplace_back 函数：在尾部就地构建元素 + template + void emplace_back(Args&& ...args); + + // emplace 函数：在指定位置就地构建元素 + template + iterator emplace(iterator pos, Args&& ...args); + + // push_front 函数：在头部插入元素 + void push_front(const value_type& value); + + // push_back 函数：在尾部插入元素 + void push_back(const value_type& value); + + // push_front 函数：在头部移动插入元素 + void push_front(value_type&& value) { emplace_front(mystl::move(value)); } + + // push_back 函数：在尾部移动插入元素 + void push_back(value_type&& value) { emplace_back(mystl::move(value)); } + + // pop_front 函数：弹出头部元素 + void pop_front(); + + // pop_back 函数：弹出尾部元素 + void pop_back(); + + // insert 函数：在指定位置插入元素 + iterator insert(iterator position, const value_type& value); + + // insert 函数：在指定位置移动插入元素 + iterator insert(iterator position, value_type&& value); + + // insert 函数：在指定位置插入 n 个元素 + void insert(iterator position, size_type n, const value_type& value); + + // insert 函数：从输入迭代器插入元素 + template ::value, int>::type = 0> + void insert(iterator position, IIter first, IIter last) + { + insert_dispatch(position, first, last, iterator_category(first)); + } // 调用 insert_dispatch 函数 + +// erase 函数：删除指定位置的元素 + iterator erase(iterator position); + + // erase 函数：删除指定范围的元素 + iterator erase(iterator first, iterator last); + + // clear 函数：清空 deque + void clear(); + + // swap 函数：交换两个 deque + void swap(deque& rhs) noexcept; private: - // 用以下四个数据来表现一个 deque - iterator begin_; // 指向第一个节点 - iterator end_; // 指向最后一个结点 - map_pointer map_; // 指向一块 map，map 中的每个元素都是一个指针，指向一个缓冲区 - size_type map_size_; // map 内指针的数目 - -public: - // 构造、复制、移动、析构函数 - - deque() - { fill_init(0, value_type()); } - - explicit deque(size_type n) - { fill_init(n, value_type()); } - - deque(size_type n, const value_type& value) - { fill_init(n, value); } - - template ::value, int>::type = 0> - deque(IIter first, IIter last) - { copy_init(first, last, iterator_category(first)); } - - deque(std::initializer_list ilist) - { - copy_init(ilist.begin(), ilist.end(), mystl::forward_iterator_tag()); - } - - deque(const deque& rhs) - { - copy_init(rhs.begin(), rhs.end(), mystl::forward_iterator_tag()); - } - deque(deque&& rhs) noexcept - :begin_(mystl::move(rhs.begin_)), - end_(mystl::move(rhs.end_)), - map_(rhs.map_), - map_size_(rhs.map_size_) - { - rhs.map_ = nullptr; - rhs.map_size_ = 0; - } + // helper functions - deque& operator=(const deque& rhs); - deque& operator=(deque&& rhs); + // create_node 函数：创建节点 + map_pointer create_map(size_type size); - deque& operator=(std::initializer_list ilist) - { - deque tmp(ilist); - swap(tmp); - return *this; - } - - ~deque() - { - if (map_ != nullptr) - { - clear(); - data_allocator::deallocate(*begin_.node, buffer_size); - *begin_.node = nullptr; - map_allocator::deallocate(map_, map_size_); - map_ = nullptr; - } - } - -public: - // 迭代器相关操作 - - iterator begin() noexcept - { return begin_; } - const_iterator begin() const noexcept - { return begin_; } - iterator end() noexcept - { return end_; } - const_iterator end() const noexcept - { return end_; } - - reverse_iterator rbegin() noexcept - { return reverse_iterator(end()); } - const_reverse_iterator rbegin() const noexcept - { return reverse_iterator(end()); } - reverse_iterator rend() noexcept - { return reverse_iterator(begin()); } - const_reverse_iterator rend() const noexcept - { return 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 { return begin() == end(); } - size_type size() const noexcept { return end_ - begin_; } - size_type max_size() const noexcept { return static_cast(-1); } - void resize(size_type new_size) { resize(new_size, value_type()); } - void resize(size_type new_size, const value_type& value); - void shrink_to_fit() noexcept; - - // 访问元素相关操作 - reference operator[](size_type n) - { - MYSTL_DEBUG(n < size()); - return begin_[n]; - } - const_reference operator[](size_type n) const - { - MYSTL_DEBUG(n < size()); - return begin_[n]; - } - - reference at(size_type n) - { - THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); - return (*this)[n]; - } - const_reference at(size_type n) const - { - THROW_OUT_OF_RANGE_IF(!(n < size()), "deque::at() subscript out of range"); - return (*this)[n]; - } - - reference front() - { - MYSTL_DEBUG(!empty()); - return *begin(); - } - const_reference front() const - { - MYSTL_DEBUG(!empty()); - return *begin(); - } - reference back() - { - MYSTL_DEBUG(!empty()); - return *(end() - 1); - } - const_reference back() const - { - MYSTL_DEBUG(!empty()); - return *(end() - 1); - } - - // 修改容器相关操作 - - // assign - - void assign(size_type n, const value_type& value) - { fill_assign(n, value); } - - template ::value, int>::type = 0> - void assign(IIter first, IIter last) - { copy_assign(first, last, iterator_category(first)); } - - void assign(std::initializer_list ilist) - { copy_assign(ilist.begin(), ilist.end(), mystl::forward_iterator_tag{}); } - - // emplace_front / emplace_back / emplace - - template - void emplace_front(Args&& ...args); - template - void emplace_back(Args&& ...args); - template - iterator emplace(iterator pos, Args&& ...args); - - // push_front / push_back - - void push_front(const value_type& value); - void push_back(const value_type& value); - - void push_front(value_type&& value) { emplace_front(mystl::move(value)); } - void push_back(value_type&& value) { emplace_back(mystl::move(value)); } - - // pop_back / pop_front - - void pop_front(); - void pop_back(); - - // insert - - iterator insert(iterator position, const value_type& value); - iterator insert(iterator position, value_type&& value); - void insert(iterator position, size_type n, const value_type& value); - template ::value, int>::type = 0> - void insert(iterator position, IIter first, IIter last) - { insert_dispatch(position, first, last, iterator_category(first)); } - - // erase /clear - - iterator erase(iterator position); - iterator erase(iterator first, iterator last); - void clear(); - - // swap - - void swap(deque& rhs) noexcept; + // create_buffer 函数：创建缓冲区 + void create_buffer(map_pointer nstart, map_pointer nfinish); -private: - // helper functions - - // create node / destroy node - map_pointer create_map(size_type size); - void create_buffer(map_pointer nstart, map_pointer nfinish); - void destroy_buffer(map_pointer nstart, map_pointer nfinish); - - // initialize - void map_init(size_type nelem); - void fill_init(size_type n, const value_type& value); - template - void copy_init(IIter, IIter, input_iterator_tag); - template - void copy_init(FIter, FIter, forward_iterator_tag); - - // assign - void fill_assign(size_type n, const value_type& value); - template - void copy_assign(IIter first, IIter last, input_iterator_tag); - template - void copy_assign(FIter first, FIter last, forward_iterator_tag); - - // insert - template - iterator insert_aux(iterator position, Args&& ...args); - void fill_insert(iterator position, size_type n, const value_type& x); - template - void copy_insert(iterator, FIter, FIter, size_type); - template - void insert_dispatch(iterator, IIter, IIter, input_iterator_tag); - template - void insert_dispatch(iterator, FIter, FIter, forward_iterator_tag); - - // reallocate - void require_capacity(size_type n, bool front); - void reallocate_map_at_front(size_type need); - void reallocate_map_at_back(size_type need); + // destroy_buffer 函数：销毁缓冲区 + void destroy_buffer(map_pointer nstart, map_pointer nfinish); + + // map_init 函数：初始化 map + void map_init(size_type nelem); + + // fill_init 函数：填充初始化 + void fill_init(size_type n, const value_type& value); + + // copy_init 函数：复制初始化（输入迭代器） + template + void copy_init(IIter, IIter, input_iterator_tag); + + // copy_init 函数：复制初始化（前向迭代器） + template + void copy_init(FIter, FIter, forward_iterator_tag); + + // assign 函数：填充赋值 + void fill_assign(size_type n, const value_type& value); + + // copy_assign 函数：复制赋值（输入迭代器） + template + void copy_assign(IIter first, IIter last, input_iterator_tag); + + // copy_assign 函数：复制赋值（前向迭代器） + template + void copy_assign(FIter first, FIter last, forward_iterator_tag); + + // insert_aux 函数：辅助插入函数 + template + iterator insert_aux(iterator position, Args&& ...args); + + // fill_insert 函数：填充插入 + void fill_insert(iterator position, size_type n, const value_type& x); + + // copy_insert 函数：复制插入 + template + void copy_insert(iterator, FIter, FIter, size_type); + + // insert_dispatch 函数：插入分派（输入迭代器） + template + void insert_dispatch(iterator, IIter, IIter, input_iterator_tag); + + // insert_dispatch 函数：插入分派（前向迭代器） + template + void insert_dispatch(iterator, FIter, FIter, forward_iterator_tag); + + // require_capacity 函数：要求容量 + void require_capacity(size_type n, bool front); + + // reallocate_map_at_front 函数：在前面重新分配 map + void reallocate_map_at_front(size_type need); + + // reallocate_map_at_back 函数：在后面重新分配 map + void reallocate_map_at_back(size_type need); }; @@ -485,93 +610,99 @@ private: template deque& deque::operator=(const deque& rhs) { - if (this != &rhs) - { - const auto len = size(); - if (len >= rhs.size()) - { - erase(mystl::copy(rhs.begin_, rhs.end_, begin_), end_); - } - else + if (this != &rhs) { - iterator mid = rhs.begin() + static_cast(len); - mystl::copy(rhs.begin_, mid, begin_); - insert(end_, mid, rhs.end_); + const auto len = size(); + if (len >= rhs.size()) + { + erase(mystl::copy(rhs.begin_, rhs.end_, begin_), end_); + } + else + { + iterator mid = rhs.begin() + static_cast(len); + mystl::copy(rhs.begin_, mid, begin_); + insert(end_, mid, rhs.end_); + } } - } - return *this; + return *this; } // 移动赋值运算符 template deque& deque::operator=(deque&& rhs) { - clear(); - begin_ = mystl::move(rhs.begin_); - end_ = mystl::move(rhs.end_); - map_ = rhs.map_; - map_size_ = rhs.map_size_; - rhs.map_ = nullptr; - rhs.map_size_ = 0; - return *this; + clear(); + begin_ = mystl::move(rhs.begin_); + end_ = mystl::move(rhs.end_); + map_ = rhs.map_; + map_size_ = rhs.map_size_; + rhs.map_ = nullptr; + rhs.map_size_ = 0; + return *this; } // 重置容器大小 template void deque::resize(size_type new_size, const value_type& value) { - const auto len = size(); - if (new_size < len) - { - erase(begin_ + new_size, end_); - } - else - { - insert(end_, new_size - len, value); - } + const auto len = size(); + if (new_size < len) + { + erase(begin_ + new_size, end_); + } + else + { + insert(end_, new_size - len, value); + } } // 减小容器容量 template void deque::shrink_to_fit() noexcept { - // 至少会留下头部缓冲区 - for (auto cur = map_; cur < begin_.node; ++cur) - { - data_allocator::deallocate(*cur, buffer_size); - *cur = nullptr; - } - for (auto cur = end_.node + 1; cur < map_ + map_size_; ++cur) - { - data_allocator::deallocate(*cur, buffer_size); - *cur = nullptr; - } + // 至少会留下头部缓冲区 + for (auto cur = map_; cur < begin_.node; ++cur) + { + data_allocator::deallocate(*cur, buffer_size); + *cur = nullptr; + } + for (auto cur = end_.node + 1; cur < map_ + map_size_; ++cur) + { + data_allocator::deallocate(*cur, buffer_size); + *cur = nullptr; + } } - // 在头部就地构建元素 template template void deque::emplace_front(Args&& ...args) { - if (begin_.cur != begin_.first) - { - data_allocator::construct(begin_.cur - 1, mystl::forward(args)...); - --begin_.cur; - } - else - { - require_capacity(1, true); - try + // 如果当前不是缓冲区的第一个元素 + if (begin_.cur != begin_.first) { - --begin_; - data_allocator::construct(begin_.cur, mystl::forward(args)...); + // 在当前元素前构造新元素 + data_allocator::construct(begin_.cur - 1, mystl::forward(args)...); + // 更新迭代器指向前一个元素 + --begin_.cur; } - catch (...) + else { - ++begin_; - throw; + // 要求额外的容量 + require_capacity(1, true); + try + { + // 更新迭代器指向前一个缓冲区的最后一个元素 + --begin_; + // 构造新元素 + data_allocator::construct(begin_.cur, mystl::forward(args)...); + } + catch (...) + { + // 如果构造失败，恢复迭代器 + ++begin_; + throw; // 重新抛出异常 + } } - } } // 在尾部就地构建元素 @@ -579,17 +710,23 @@ template template void deque::emplace_back(Args&& ...args) { - if (end_.cur != end_.last - 1) - { - data_allocator::construct(end_.cur, mystl::forward(args)...); - ++end_.cur; - } - else - { - require_capacity(1, false); - data_allocator::construct(end_.cur, mystl::forward(args)...); - ++end_; - } + // 如果当前不是缓冲区的最后一个元素 + if (end_.cur != end_.last - 1) + { + // 在当前元素后构造新元素 + data_allocator::construct(end_.cur, mystl::forward(args)...); + // 更新迭代器指向后一个元素 + ++end_.cur; + } + else + { + // 要求额外的容量 + require_capacity(1, false); + // 构造新元素 + data_allocator::construct(end_.cur, mystl::forward(args)...); + // 更新迭代器指向后一个缓冲区的第一个元素 + ++end_; + } } // 在 pos 位置就地构建元素 @@ -597,95 +734,127 @@ template template typename deque::iterator deque::emplace(iterator pos, Args&& ...args) { - if (pos.cur == begin_.cur) - { - emplace_front(mystl::forward(args)...); - return begin_; - } - else if (pos.cur == end_.cur) - { - emplace_back(mystl::forward(args)...); - return end_ - 1; - } - return insert_aux(pos, mystl::forward(args)...); + // 如果位置在头部 + if (pos.cur == begin_.cur) + { + // 在头部构建元素 + emplace_front(mystl::forward(args)...); + return begin_; // 返回新的开始迭代器 + } + else if (pos.cur == end_.cur) // 如果位置在尾部 + { + // 在尾部构建元素 + emplace_back(mystl::forward(args)...); + return end_ - 1; // 返回新的尾部迭代器 + } + else // 如果位置在中间 + { + // 在中间位置构建元素 + return insert_aux(pos, mystl::forward(args)...); + } } // 在头部插入元素 template void deque::push_front(const value_type& value) { - if (begin_.cur != begin_.first) - { - data_allocator::construct(begin_.cur - 1, value); - --begin_.cur; - } - else - { - require_capacity(1, true); - try + // 如果当前不是缓冲区的第一个元素 + if (begin_.cur != begin_.first) { - --begin_; - data_allocator::construct(begin_.cur, value); + // 在当前元素前构造新元素 + data_allocator::construct(begin_.cur - 1, value); + // 更新迭代器指向前一个元素 + --begin_.cur; } - catch (...) + else { - ++begin_; - throw; + // 要求额外的容量 + require_capacity(1, true); + try + { + // 更新迭代器指向前一个缓冲区的最后一个元素 + --begin_; + // 构造新元素 + data_allocator::construct(begin_.cur, value); + } + catch (...) + { + // 如果构造失败，恢复迭代器 + ++begin_; + throw; // 重新抛出异常 + } } - } } // 在尾部插入元素 template void deque::push_back(const value_type& value) { - if (end_.cur != end_.last - 1) - { - data_allocator::construct(end_.cur, value); - ++end_.cur; - } - else - { - require_capacity(1, false); - data_allocator::construct(end_.cur, value); - ++end_; - } + // 如果当前不是缓冲区的最后一个元素 + if (end_.cur != end_.last - 1) + { + // 在当前元素后构造新元素 + data_allocator::construct(end_.cur, value); + // 更新迭代器指向后一个元素 + ++end_.cur; + } + else + { + // 要求额外的容量 + require_capacity(1, false); + // 构造新元素 + data_allocator::construct(end_.cur, value); + // 更新迭代器指向后一个缓冲区的第一个元素 + ++end_; + } } // 弹出头部元素 template void deque::pop_front() { - MYSTL_DEBUG(!empty()); - if (begin_.cur != begin_.last - 1) - { - data_allocator::destroy(begin_.cur); - ++begin_.cur; - } - else - { - data_allocator::destroy(begin_.cur); - ++begin_; - destroy_buffer(begin_.node - 1, begin_.node - 1); - } + MYSTL_DEBUG(!empty()); // 调试宏，检查是否为空 + // 如果当前不是缓冲区的最后一个元素 + if (begin_.cur != begin_.last - 1) + { + // 销毁当前元素 + data_allocator::destroy(begin_.cur); + // 更新迭代器指向下一个元素 + ++begin_.cur; + } + else // 如果当前是缓冲区的最后一个元素 + { + // 销毁当前元素 + data_allocator::destroy(begin_.cur); + // 更新迭代器指向下一个缓冲区的第一个元素 + ++begin_; + // 销毁当前缓冲区 + destroy_buffer(begin_.node - 1, begin_.node - 1); + } } // 弹出尾部元素 template void deque::pop_back() { - MYSTL_DEBUG(!empty()); - if (end_.cur != end_.first) - { - --end_.cur; - data_allocator::destroy(end_.cur); - } - else - { - --end_; - data_allocator::destroy(end_.cur); - destroy_buffer(end_.node + 1, end_.node + 1); - } + MYSTL_DEBUG(!empty()); // 调试宏，检查是否为空 + // 如果当前不是缓冲区的第一个元素 + if (end_.cur != end_.first) + { + // 更新迭代器指向前一个元素 + --end_.cur; + // 销毁当前元素 + data_allocator::destroy(end_.cur); + } + else // 如果当前是缓冲区的第一个元素 + { + // 更新迭代器指向前一个缓冲区的最后一个元素 + --end_; + // 销毁当前元素 + data_allocator::destroy(end_.cur); + // 销毁当前缓冲区 + destroy_buffer(end_.node + 1, end_.node + 1); + } } // 在 position 处插入元素 @@ -693,68 +862,86 @@ template typename deque::iterator deque::insert(iterator position, const value_type& value) { - if (position.cur == begin_.cur) - { - push_front(value); - return begin_; - } - else if (position.cur == end_.cur) - { - push_back(value); - auto tmp = end_; - --tmp; - return tmp; - } - else - { - return insert_aux(position, value); - } + // 如果位置在头部 + if (position.cur == begin_.cur) + { + // 在头部插入元素 + push_front(value); + return begin_; // 返回新的开始迭代器 + } + else if (position.cur == end_.cur) // 如果位置在尾部 + { + // 在尾部插入元素 + push_back(value); + auto tmp = end_; // 获取新的尾部迭代器 + --tmp; // 返回新的尾部迭代器 + return tmp; + } + else // 如果位置在中间 + { + // 在中间位置插入元素 + return insert_aux(position, value); + } } template typename deque::iterator deque::insert(iterator position, value_type&& value) { - if (position.cur == begin_.cur) - { - emplace_front(mystl::move(value)); - return begin_; - } - else if (position.cur == end_.cur) - { - emplace_back(mystl::move(value)); - auto tmp = end_; - --tmp; - return tmp; - } - else - { - return insert_aux(position, mystl::move(value)); - } + // 如果位置在头部 + if (position.cur == begin_.cur) + { + // 在头部插入元素 + emplace_front(mystl::move(value)); + return begin_; // 返回新的开始迭代器 + } + else if (position.cur == end_.cur) // 如果位置在尾部 + { + // 在尾部插入元素 + emplace_back(mystl::move(value)); + auto tmp = end_; // 获取新的尾部迭代器 + --tmp; // 返回新的尾部迭代器 + return tmp; + } + else // 如果位置在中间 + { + // 在中间位置插入元素 + return insert_aux(position, mystl::move(value)); + } } // 在 position 位置插入 n 个元素 template void deque::insert(iterator position, size_type n, const value_type& value) { - if (position.cur == begin_.cur) - { - require_capacity(n, true); - auto new_begin = begin_ - n; - mystl::uninitialized_fill_n(new_begin, n, value); - begin_ = new_begin; - } - else if (position.cur == end_.cur) - { - require_capacity(n, false); - auto new_end = end_ + n; - mystl::uninitialized_fill_n(end_, n, value); - end_ = new_end; - } - else - { - fill_insert(position, n, value); - } + // 如果位置在头部 + if (position.cur == begin_.cur) + { + // 要求额外的容量 + require_capacity(n, true); + // 计算新的开始位置 + auto new_begin = begin_ - n; + // 在新位置填充元素 + mystl::uninitialized_fill_n(new_begin, n, value); + // 更新开始迭代器 + begin_ = new_begin; + } + else if (position.cur == end_.cur) // 如果位置在尾部 + { + // 要求额外的容量 + require_capacity(n, false); + // 计算新的结束位置 + auto new_end = end_ + n; + // 在新位置填充元素 + mystl::uninitialized_fill_n(end_, n, value); + // 更新结束迭代器 + end_ = new_end; + } + else // 如果位置在中间 + { + // 在中间位置插入元素 + fill_insert(position, n, value); + } } // 删除 position 处的元素 @@ -762,20 +949,28 @@ template typename deque::iterator deque::erase(iterator position) { - auto next = position; - ++next; - const size_type elems_before = position - begin_; - if (elems_before < (size() / 2)) - { - mystl::copy_backward(begin_, position, next); - pop_front(); - } - else - { - mystl::copy(next, end_, position); - pop_back(); - } - return begin_ + elems_before; + // 获取下一个元素的迭代器 + auto next = position; + ++next; + // 计算位置之前的元素数量 + const size_type elems_before = position - begin_; + // 如果位置在前半部分 + if (elems_before < (size() / 2)) + { + // 向后复制元素 + mystl::copy_backward(begin_, position, next); + // 弹出头部元素 + pop_front(); + } + else // 如果位置在后半部分 + { + // 向前复制元素 + mystl::copy(next, end_, position); + // 弹出尾部元素 + pop_back(); + } + // 返回新的迭代器位置 + return begin_ + elems_before; } // 删除[first, last)上的元素 @@ -783,642 +978,847 @@ template typename deque::iterator deque::erase(iterator first, iterator last) { - if (first == begin_ && last == end_) - { - clear(); - return end_; - } - else - { - const size_type len = last - first; - const size_type elems_before = first - begin_; - if (elems_before < ((size() - len) / 2)) - { - mystl::copy_backward(begin_, first, last); - auto new_begin = begin_ + len; - data_allocator::destroy(begin_.cur, new_begin.cur); - begin_ = new_begin; + // 如果删除整个范围 + if (first == begin_ && last == end_) + { + // 清空 deque + clear(); + return end_; // 返回结束迭代器 } - else + else // 如果删除部分范围 { - mystl::copy(last, end_, first); - auto new_end = end_ - len; - data_allocator::destroy(new_end.cur, end_.cur); - end_ = new_end; + // 计算要删除的元素数量 + const size_type len = last - first; + // 计算 first 之前的元素数量 + const size_type elems_before = first - begin_; + // 如果 first 在前半部分 + if (elems_before < ((size() - len) / 2)) + { + // 向后复制元素 + mystl::copy_backward(begin_, first, last); + // 计算新的开始位置 + auto new_begin = begin_ + len; + // 销毁多余元素 + data_allocator::destroy(begin_.cur, new_begin.cur); + // 更新开始迭代器 + begin_ = new_begin; + } + else // 如果 first 在后半部分 + { + // 向前复制元素 + mystl::copy(last, end_, first); + // 计算新的结束位置 + auto new_end = end_ - len; + // 销毁多余元素 + data_allocator::destroy(new_end.cur, end_.cur); + // 更新结束迭代器 + end_ = new_end; + } + // 返回新的迭代器位置 + return begin_ + elems_before; } - return begin_ + elems_before; - } } // 清空 deque template void deque::clear() { - // clear 会保留头部的缓冲区 - for (map_pointer cur = begin_.node + 1; cur < end_.node; ++cur) - { - data_allocator::destroy(*cur, *cur + buffer_size); - } - if (begin_.node != end_.node) - { // 有两个以上的缓冲区 - mystl::destroy(begin_.cur, begin_.last); - mystl::destroy(end_.first, end_.cur); - } - else - { - mystl::destroy(begin_.cur, end_.cur); - } - shrink_to_fit(); - end_ = begin_; + // 清空 deque 会保留头部的缓冲区 + for (map_pointer cur = begin_.node + 1; cur < end_.node; ++cur) // 遍历中间缓冲区 + { + // 销毁缓冲区中的元素 + data_allocator::destroy(*cur, *cur + buffer_size); + } + if (begin_.node != end_.node) // 如果有多个缓冲区 + { + // 销毁头部缓冲区中的元素 + mystl::destroy(begin_.cur, begin_.last); + // 销毁尾部缓冲区中的元素 + mystl::destroy(end_.first, end_.cur); + } + else // 如果只有一个缓冲区 + { + // 销毁缓冲区中的元素 + mystl::destroy(begin_.cur, end_.cur); + } + // 减小容量以适应大小 + shrink_to_fit(); + // 更新结束迭代器 + end_ = begin_; } // 交换两个 deque template void deque::swap(deque& rhs) noexcept { - if (this != &rhs) - { - mystl::swap(begin_, rhs.begin_); - mystl::swap(end_, rhs.end_); - mystl::swap(map_, rhs.map_); - mystl::swap(map_size_, rhs.map_size_); - } + if (this != &rhs) // 如果不是交换自身 + { + // 交换开始迭代器 + mystl::swap(begin_, rhs.begin_); + // 交换结束迭代器 + mystl::swap(end_, rhs.end_); + // 交换映射指针 + mystl::swap(map_, rhs.map_); + // 交换映射大小 + mystl::swap(map_size_, rhs.map_size_); + } } - /*****************************************************************************************/ // helper function +// 创建 map template typename deque::map_pointer deque::create_map(size_type size) { - map_pointer mp = nullptr; - mp = map_allocator::allocate(size); - for (size_type i = 0; i < size; ++i) - *(mp + i) = nullptr; - return mp; + // 初始化映射指针为 nullptr + map_pointer mp = nullptr; + // 分配映射空间 + mp = map_allocator::allocate(size); + // 初始化映射指针为 nullptr + for (size_type i = 0; i < size; ++i) + *(mp + i) = nullptr; + // 返回映射指针 + return mp; } -// create_buffer 函数 +// 创建缓冲区 template -void deque:: -create_buffer(map_pointer nstart, map_pointer nfinish) +void deque::create_buffer(map_pointer nstart, map_pointer nfinish) { - map_pointer cur; - try - { - for (cur = nstart; cur <= nfinish; ++cur) + // 遍历缓冲区 + map_pointer cur; + try { - *cur = data_allocator::allocate(buffer_size); + for (cur = nstart; cur <= nfinish; ++cur) + { + // 分配缓冲区空间 + *cur = data_allocator::allocate(buffer_size); + } } - } - catch (...) - { - while (cur != nstart) + catch (...) { - --cur; - data_allocator::deallocate(*cur, buffer_size); - *cur = nullptr; + // 如果分配失败，释放已分配的缓冲区 + while (cur != nstart) + { + --cur; + data_allocator::deallocate(*cur, buffer_size); + *cur = nullptr; + } + throw; // 重新抛出异常 } - throw; - } } -// destroy_buffer 函数 +// 销毁缓冲区 template -void deque:: -destroy_buffer(map_pointer nstart, map_pointer nfinish) +void deque::destroy_buffer(map_pointer nstart, map_pointer nfinish) { - for (map_pointer n = nstart; n <= nfinish; ++n) - { - data_allocator::deallocate(*n, buffer_size); - *n = nullptr; - } + // 遍历缓冲区 + for (map_pointer n = nstart; n <= nfinish; ++n) + { + // 释放缓冲区空间 + data_allocator::deallocate(*n, buffer_size); + // 设置缓冲区指针为 nullptr + *n = nullptr; + } } -// map_init 函数 +// 初始化 map template -void deque:: -map_init(size_type nElem) +void deque::map_init(size_type nelem) { - const size_type nNode = nElem / buffer_size + 1; // 需要分配的缓冲区个数 - map_size_ = mystl::max(static_cast(DEQUE_MAP_INIT_SIZE), nNode + 2); - try - { - map_ = create_map(map_size_); - } - catch (...) - { - map_ = nullptr; - map_size_ = 0; - throw; - } - - // 让 nstart 和 nfinish 都指向 map_ 最中央的区域，方便向头尾扩充 - map_pointer nstart = map_ + (map_size_ - nNode) / 2; - map_pointer nfinish = nstart + nNode - 1; - try - { - create_buffer(nstart, nfinish); - } - catch (...) - { - map_allocator::deallocate(map_, map_size_); - map_ = nullptr; - map_size_ = 0; - throw; - } - begin_.set_node(nstart); - end_.set_node(nfinish); - begin_.cur = begin_.first; - end_.cur = end_.first + (nElem % buffer_size); + // 计算需要的缓冲区数量 + const size_type nNode = nelem / buffer_size + 1; + // 计算映射大小 + map_size_ = mystl::max(static_cast(DEQUE_MAP_INIT_SIZE), nNode + 2); + try + { + // 创建映射 + map_ = create_map(map_size_); + } + catch (...) + { + // 如果创建失败，设置映射指针为 nullptr + map_ = nullptr; + // 设置映射大小为 0 + map_size_ = 0; + throw; // 重新抛出异常 + } + + // 让 nstart 和 nfinish 都指向 map_ 最中央的区域，方便向头尾扩充 + map_pointer nstart = map_ + (map_size_ - nNode) / 2; + map_pointer nfinish = nstart + nNode - 1; + try + { + // 创建缓冲区 + create_buffer(nstart, nfinish); + } + catch (...) + { + // 如果创建失败，释放映射空间 + map_allocator::deallocate(map_, map_size_); + // 设置映射指针为 nullptr + map_ = nullptr; + // 设置映射大小为 0 + map_size_ = 0; + throw; // 重新抛出异常 + } + // 设置开始迭代器的节点 + begin_.set_node(nstart); + // 设置结束迭代器的节点 + end_.set_node(nfinish); + // 设置开始迭代器的当前元素 + begin_.cur = begin_.first; + // 设置结束迭代器的当前元素 + end_.cur = end_.first + (nelem % buffer_size); } -// fill_init 函数 +// 填充初始化 template -void deque:: -fill_init(size_type n, const value_type& value) +void deque::fill_init(size_type n, const value_type& value) { - map_init(n); - if (n != 0) - { - for (auto cur = begin_.node; cur < end_.node; ++cur) + // 初始化映射 + map_init(n); + if (n != 0) // 如果需要初始化的元素数量不为 0 { - mystl::uninitialized_fill(*cur, *cur + buffer_size, value); + // 遍历缓冲区 + for (auto cur = begin_.node; cur < end_.node; ++cur) + { + // 填充缓冲区 + mystl::uninitialized_fill(*cur, *cur + buffer_size, value); + } + // 填充尾部缓冲区 + mystl::uninitialized_fill(end_.first, end_.cur, value); } - mystl::uninitialized_fill(end_.first, end_.cur, value); - } } -// copy_init 函数 +// 复制初始化（输入迭代器） template template -void deque:: -copy_init(IIter first, IIter last, input_iterator_tag) +void deque::copy_init(IIter first, IIter last, input_iterator_tag) { - const size_type n = mystl::distance(first, last); - map_init(n); - for (; first != last; ++first) - emplace_back(*first); + // 计算需要初始化的元素数量 + const size_type n = mystl::distance(first, last); + // 初始化映射 + map_init(n); + // 遍历输入迭代器 + for (; first != last; ++first) + // 在尾部插入元素 + emplace_back(*first); } +// 复制初始化（前向迭代器） template template -void deque:: -copy_init(FIter first, FIter last, forward_iterator_tag) +void deque::copy_init(FIter first, FIter last, forward_iterator_tag) { - const size_type n = mystl::distance(first, last); - map_init(n); - for (auto cur = begin_.node; cur < end_.node; ++cur) - { - auto next = first; - mystl::advance(next, buffer_size); - mystl::uninitialized_copy(first, next, *cur); - first = next; - } - mystl::uninitialized_copy(first, last, end_.first); + // 计算需要初始化的元素数量 + const size_type n = mystl::distance(first, last); + // 初始化映射 + map_init(n); + // 遍历缓冲区 + for (auto cur = begin_.node; cur < end_.node; ++cur) + { + // 获取下一个元素的迭代器 + auto next = first; + // 移动到下一个缓冲区的开始位置 + mystl::advance(next, buffer_size); + // 复制元素到当前缓冲区 + mystl::uninitialized_copy(first, next, *cur); + // 更新迭代器 + first = next; + } + // 复制剩余元素到尾部缓冲区 + mystl::uninitialized_copy(first, last, end_.first); } -// fill_assign 函数 +// 填充赋值 template -void deque:: -fill_assign(size_type n, const value_type& value) +void deque::fill_assign(size_type n, const value_type& value) { - if (n > size()) - { - mystl::fill(begin(), end(), value); - insert(end(), n - size(), value); - } - else - { - erase(begin() + n, end()); - mystl::fill(begin(), end(), value); - } + // 如果需要分配的元素数量大于当前大小 + if (n > size()) + { + // 填充现有元素 + mystl::fill(begin(), end(), value); + // 插入额外的元素 + insert(end(), n - size(), value); + } + else // 如果需要分配的元素数量小于或等于当前大小 + { + // 删除多余的元素 + erase(begin() + n, end()); + // 填充现有元素 + mystl::fill(begin(), end(), value); + } } -// copy_assign 函数 +// 复制赋值（输入迭代器） template template -void deque:: -copy_assign(IIter first, IIter last, input_iterator_tag) +void deque::copy_assign(IIter first, IIter last, input_iterator_tag) { - auto first1 = begin(); - auto last1 = end(); - for (; first != last && first1 != last1; ++first, ++first1) - { - *first1 = *first; - } - if (first1 != last1) - { - erase(first1, last1); - } - else - { - insert_dispatch(end_, first, last, input_iterator_tag{}); - } + // 获取开始迭代器 + auto first1 = begin(); + // 获取结束迭代器 + auto last1 = end(); + // 遍历输入迭代器和当前迭代器 + for (; first != last && first1 != last1; ++first, ++first1) + { + // 赋值元素 + *first1 = *first; + } + if (first1 != last1) // 如果当前迭代器未结束 + { + // 删除多余的元素 + erase(first1, last1); + } + else // 如果输入迭代器未结束 + { + // 插入剩余的元素 + insert_dispatch(end_, first, last, input_iterator_tag{}); + } } +// 复制赋值（前向迭代器） template template -void deque:: -copy_assign(FIter first, FIter last, forward_iterator_tag) -{ - const size_type len1 = size(); - const size_type len2 = mystl::distance(first, last); - if (len1 < len2) - { - auto next = first; - mystl::advance(next, len1); - mystl::copy(first, next, begin_); - insert_dispatch(end_, next, last, forward_iterator_tag{}); - } - else - { - erase(mystl::copy(first, last, begin_), end_); - } +void deque::copy_assign(FIter first, FIter last, forward_iterator_tag) +{ + // 获取当前大小 + const size_type len1 = size(); + // 获取输入迭代器的大小 + const size_type len2 = mystl::distance(first, last); + if (len1 < len2) // 如果当前大小小于输入迭代器的大小 + { + // 获取下一个元素的迭代器 + auto next = first; + // 移动到下一个缓冲区的开始位置 + mystl::advance(next, len1); + // 复制元素到当前缓冲区 + mystl::copy(first, next, begin_); + // 插入剩余的元素 + insert_dispatch(end_, next, last, forward_iterator_tag{}); + } + else // 如果当前大小大于或等于输入迭代器的大小 + { + // 复制元素并删除多余的元素 + erase(mystl::copy(first, last, begin_), end_); + } } -// insert_aux 函数 +// 辅助插入函数 template template typename deque::iterator -deque:: -insert_aux(iterator position, Args&& ...args) +deque::insert_aux(iterator position, Args&& ...args) { - const size_type elems_before = position - begin_; - value_type value_copy = value_type(mystl::forward(args)...); - if (elems_before < (size() / 2)) - { // 在前半段插入 - emplace_front(front()); - auto front1 = begin_; - ++front1; - auto front2 = front1; - ++front2; - position = begin_ + elems_before; - auto pos = position; - ++pos; - mystl::copy(front2, pos, front1); - } - else - { // 在后半段插入 - emplace_back(back()); - auto back1 = end_; - --back1; - auto back2 = back1; - --back2; - position = begin_ + elems_before; - mystl::copy_backward(position, back2, back1); - } - *position = mystl::move(value_copy); - return position; + // 计算位置之前的元素数量 + const size_type elems_before = position - begin_; + // 创建元素副本 + value_type value_copy = value_type(mystl::forward(args)...); + if (elems_before < (size() / 2)) // 如果位置在前半部分 + { // 在前半段插入 + // 在头部插入元素 + emplace_front(front()); + // 获取开始迭代器 + auto front1 = begin_; + // 移动到下一个元素 + ++front1; + // 获取下一个元素的迭代器 + auto front2 = front1; + // 移动到下一个元素 + ++front2; + // 更新位置迭代器 + position = begin_ + elems_before; + // 获取位置迭代器 + auto pos = position; + // 移动到下一个元素 + ++pos; + // 向前复制元素 + mystl::copy(front2, pos, front1); + } + else // 如果位置在后半部分 + { // 在后半段插入 + // 在尾部插入元素 + emplace_back(back()); + // 获取结束迭代器 + auto back1 = end_; + // 移动到前一个元素 + --back1; + // 获取前一个元素的迭代器 + auto back2 = back1; + // 移动到前一个元素 + --back2; + // 更新位置迭代器 + position = begin_ + elems_before; + // 向后复制元素 + mystl::copy_backward(position, back2, back1); + } + // 赋值元素 + *position = mystl::move(value_copy); + // 返回位置迭代器 + return position; } -// fill_insert 函数 +// 填充插入 template -void deque:: -fill_insert(iterator position, size_type n, const value_type& value) +void deque::fill_insert(iterator position, size_type n, const value_type& x) { - const size_type elems_before = position - begin_; - const size_type len = size(); - auto value_copy = value; - if (elems_before < (len / 2)) - { - require_capacity(n, true); - // 原来的迭代器可能会失效 - auto old_begin = begin_; - auto new_begin = begin_ - n; - position = begin_ + elems_before; - try + // 计算位置之前的元素数量 + const size_type elems_before = position - begin_; + // 获取当前大小 + const size_type len = size(); + // 创建元素副本 + auto value_copy = x; + if (elems_before < (len / 2)) // 如果位置在前半部分 { - if (elems_before >= n) - { - auto begin_n = begin_ + n; - mystl::uninitialized_copy(begin_, begin_n, new_begin); - begin_ = new_begin; - mystl::copy(begin_n, position, old_begin); - mystl::fill(position - n, position, value_copy); - } - else - { - mystl::uninitialized_fill( - mystl::uninitialized_copy(begin_, position, new_begin), begin_, value_copy); - begin_ = new_begin; - mystl::fill(old_begin, position, value_copy); - } + // 要求额外的容量 + require_capacity(n, true); + // 获取开始迭代器 + auto old_begin = begin_; + // 计算新的开始位置 + auto new_begin = begin_ - n; + // 更新位置迭代器 + position = begin_ + elems_before; + try + { + if (elems_before >= n) // 如果位置之前的元素数量大于或等于 n + { + // 获取新的开始位置 + auto begin_n = begin_ + n; + // 复制元素到新的开始位置 + mystl::uninitialized_copy(begin_, begin_n, new_begin); + // 更新开始迭代器 + begin_ = new_begin; + // 向前复制元素 + mystl::copy(begin_n, position, old_begin); + // 填充元素 + mystl::fill(position - n, position, value_copy); + } + else // 如果位置之前的元素数量小于 n + { + // 填充元素 + mystl::uninitialized_fill( + mystl::uninitialized_copy(begin_, position, new_begin), begin_, value_copy); + // 更新开始迭代器 + begin_ = new_begin; + // 填充元素 + mystl::fill(old_begin, position, value_copy); + } + } + catch (...) + { + if (new_begin.node != begin_.node) // 如果新的开始位置不在当前缓冲区 + // 销毁缓冲区 + destroy_buffer(new_begin.node, begin_.node - 1); + throw; // 重新抛出异常 + } } - catch (...) + else // 如果位置在后半部分 { - if (new_begin.node != begin_.node) - destroy_buffer(new_begin.node, begin_.node - 1); - throw; - } - } - else - { - require_capacity(n, false); - // 原来的迭代器可能会失效 - auto old_end = end_; - auto new_end = end_ + n; - const size_type elems_after = len - elems_before; - position = end_ - elems_after; - try - { - if (elems_after > n) - { - auto end_n = end_ - n; - mystl::uninitialized_copy(end_n, end_, end_); - end_ = new_end; - mystl::copy_backward(position, end_n, old_end); - mystl::fill(position, position + n, value_copy); - } - else - { - mystl::uninitialized_fill(end_, position + n, value_copy); - mystl::uninitialized_copy(position, end_, position + n); - end_ = new_end; - mystl::fill(position, old_end, value_copy); - } + // 要求额外的容量 + require_capacity(n, false); + // 获取结束迭代器 + auto old_end = end_; + // 计算新的结束位置 + auto new_end = end_ + n; + // 计算位置之后的元素数量 + const size_type elems_after = len - elems_before; + // 更新位置迭代器 + position = end_ - elems_after; + try + { + if (elems_after > n) // 如果位置之后的元素数量大于 n + { + // 获取新的结束位置 + auto end_n = end_ - n; + // 复制元素到新的结束位置 + mystl::uninitialized_copy(end_n, end_, end_); + // 更新结束迭代器 + end_ = new_end; + // 向后复制元素 + mystl::copy_backward(position, end_n, old_end); + // 填充元素 + mystl::fill(position, position + n, value_copy); + } + else // 如果位置之后的元素数量小于或等于 n + { + // 填充元素 + mystl::uninitialized_fill(end_, position + n, value_copy); + // 复制元素 + mystl::uninitialized_copy(position, old_end, position + n); + // 更新结束迭代器 + end_ = new_end; + // 填充元素 + mystl::fill(position, old_end, value_copy); + } + } + catch (...) + { + if (new_end.node != end_.node) // 如果新的结束位置不在当前缓冲区 + // 销毁缓冲区 + destroy_buffer(end_.node + 1, new_end.node); + throw; // 重新抛出异常 + } } - catch (...) - { - if(new_end.node != end_.node) - destroy_buffer(end_.node + 1, new_end.node); - throw; - } - } } -// copy_insert +// 复制插入 template template -void deque:: -copy_insert(iterator position, FIter first, FIter last, size_type n) +void deque::copy_insert(iterator position, FIter first, FIter last, size_type n) { - const size_type elems_before = position - begin_; - auto len = size(); - if (elems_before < (len / 2)) - { - require_capacity(n, true); - // 原来的迭代器可能会失效 - auto old_begin = begin_; - auto new_begin = begin_ - n; - position = begin_ + elems_before; - try + // 计算位置之前的元素数量 + const size_type elems_before = position - begin_; + // 获取当前大小 + auto len = size(); + if (elems_before < (len / 2)) // 如果位置在前半部分 { - if (elems_before >= n) - { - auto begin_n = begin_ + n; - mystl::uninitialized_copy(begin_, begin_n, new_begin); - begin_ = new_begin; - mystl::copy(begin_n, position, old_begin); - mystl::copy(first, last, position - n); - } - else - { - auto mid = first; - mystl::advance(mid, n - elems_before); - mystl::uninitialized_copy(first, mid, - mystl::uninitialized_copy(begin_, position, new_begin)); - begin_ = new_begin; - mystl::copy(mid, last, old_begin); - } + // 要求额外的容量 + require_capacity(n, true); + // 获取开始迭代器 + auto old_begin = begin_; + // 计算新的开始位置 + auto new_begin = begin_ - n; + // 更新位置迭代器 + position = begin_ + elems_before; + try + { + if (elems_before >= n) // 如果位置之前的元素数量大于或等于 n + { + // 获取新的开始位置 + auto begin_n = begin_ + n; + // 复制元素到新的开始位置 + mystl::uninitialized_copy(begin_, begin_n, new_begin); + // 更新开始迭代器 + begin_ = new_begin; + // 向前复制元素 + mystl::copy(begin_n, position, old_begin); + // 复制新元素 + mystl::copy(first, last, position - n); + } + else // 如果位置之前的元素数量小于 n + { + // 获取中间位置的迭代器 + auto mid = first; + // 移动到中间位置 + mystl::advance(mid, n - elems_before); + // 复制新元素到新的开始位置 + mystl::uninitialized_copy(first, mid, + mystl::uninitialized_copy(begin_, position, new_begin)); + // 更新开始迭代器 + begin_ = new_begin; + // 复制剩余的新元素 + mystl::copy(mid, last, old_begin); + } + } + catch (...) + { + if (new_begin.node != begin_.node) // 如果新的开始位置不在当前缓冲区 + // 销毁缓冲区 + destroy_buffer(new_begin.node, begin_.node - 1); + throw; // 重新抛出异常 + } } - catch (...) - { - if(new_begin.node != begin_.node) - destroy_buffer(new_begin.node, begin_.node - 1); - throw; - } - } - else - { - require_capacity(n, false); - // 原来的迭代器可能会失效 - auto old_end = end_; - auto new_end = end_ + n; - const auto elems_after = len - elems_before; - position = end_ - elems_after; - try + else // 如果位置在后半部分 { - if (elems_after > n) - { - auto end_n = end_ - n; - mystl::uninitialized_copy(end_n, end_, end_); - end_ = new_end; - mystl::copy_backward(position, end_n, old_end); - mystl::copy(first, last, position); - } - else - { - auto mid = first; - mystl::advance(mid, elems_after); - mystl::uninitialized_copy(position, end_, - mystl::uninitialized_copy(mid, last, end_)); - end_ = new_end; - mystl::copy(first, mid, position); - } + // 要求额外的容量 + require_capacity(n, false); + // 获取结束迭代器 + auto old_end = end_; + // 计算新的结束位置 + auto new_end = end_ + n; + // 计算位置之后的元素数量 + const auto elems_after = len - elems_before; + // 更新位置迭代器 + position = end_ - elems_after; + try + { + if (elems_after > n) // 如果位置之后的元素数量大于 n + { + // 获取新的结束位置 + auto end_n = end_ - n; + // 复制元素到新的结束位置 + mystl::uninitialized_copy(end_n, end_, end_); + // 更新结束迭代器 + end_ = new_end; + // 向后复制元素 + mystl::copy_backward(position, end_n, old_end); + // 复制新元素 + mystl::copy(first, last, position); + } + else // 如果位置之后的元素数量小于或等于 n + { + // 获取中间位置的迭代器 + auto mid = first; + // 移动到中间位置 + mystl::advance(mid, elems_after); + // 复制新元素到新的结束位置 + mystl::uninitialized_copy(position, end_, + mystl::uninitialized_copy(mid, last, end_)); + // 更新结束迭代器 + end_ = new_end; + // 复制剩余的新元素 + mystl::copy(first, mid, position); + } + } + catch (...) + { + if (new_end.node != end_.node) // 如果新的结束位置不在当前缓冲区 + { + // 销毁缓冲区 + destroy_buffer(end_.node + 1, new_end.node); + } + throw; // 重新抛出异常 + } } - catch (...) - { - if(new_end.node != end_.node) - destroy_buffer(end_.node + 1, new_end.node); - throw; - } - } +} } -// insert_dispatch 函数 +// 插入分派（输入迭代器） template template -void deque:: -insert_dispatch(iterator position, IIter first, IIter last, input_iterator_tag) +void deque::insert_dispatch(iterator position, IIter first, IIter last, input_iterator_tag) { - if (last <= first) return; - const size_type n = mystl::distance(first, last); - const size_type elems_before = position - begin_; - if (elems_before < (size() / 2)) - { - require_capacity(n, true); - } - else - { - require_capacity(n, false); - } - position = begin_ + elems_before; - auto cur = --last; - for (size_type i = 0; i < n; ++i, --cur) - { - insert(position, *cur); - } + // 如果输入范围无效，直接返回 + if (last <= first) return; + // 计算需要插入的元素数量 + const size_type n = mystl::distance(first, last); + // 计算位置之前的元素数量 + const size_type elems_before = position - begin_; + if (elems_before < (size() / 2)) // 如果位置在前半部分 + { + // 要求额外的容量 + require_capacity(n, true); + } + else // 如果位置在后半部分 + { + // 要求额外的容量 + require_capacity(n, false); + } + // 更新位置迭代器 + position = begin_ + elems_before; + // 获取最后一个元素的迭代器 + auto cur = --last; + for (size_type i = 0; i < n; ++i, --cur) // 遍历输入范围 + { + // 插入元素 + insert(position, *cur); + } } +// 插入分派（前向迭代器） template template -void deque:: -insert_dispatch(iterator position, FIter first, FIter last, forward_iterator_tag) +void deque::insert_dispatch(iterator position, FIter first, FIter last, forward_iterator_tag) { - if (last <= first) return; - const size_type n = mystl::distance(first, last); - if (position.cur == begin_.cur) - { - require_capacity(n, true); - auto new_begin = begin_ - n; - try + // 如果输入范围无效，直接返回 + if (last <= first) return; + // 计算需要插入的元素数量 + const size_type n = mystl::distance(first, last); + if (position.cur == begin_.cur) // 如果位置在头部 { - mystl::uninitialized_copy(first, last, new_begin); - begin_ = new_begin; + // 要求额外的容量 + require_capacity(n, true); + auto new_begin = begin_ - n; // 计算新的开始位置 + try + { + // 复制元素到新的开始位置 + mystl::uninitialized_copy(first, last, new_begin); + // 更新开始迭代器 + begin_ = new_begin; + } + catch (...) + { + if (new_begin.node != begin_.node) // 如果新的开始位置不在当前缓冲区 + // 销毁缓冲区 + destroy_buffer(new_begin.node, begin_.node - 1); + throw; // 重新抛出异常 + } } - catch (...) + else if (position.cur == end_.cur) // 如果位置在尾部 { - if(new_begin.node != begin_.node) - destroy_buffer(new_begin.node, begin_.node - 1); - throw; + // 要求额外的容量 + require_capacity(n, false); + auto new_end = end_ + n; // 计算新的结束位置 + try + { + // 复制元素到新的结束位置 + mystl::uninitialized_copy(first, last, end_); + // 更新结束迭代器 + end_ = new_end; + } + catch (...) + { + if (new_end.node != end_.node) // 如果新的结束位置不在当前缓冲区 + // 销毁缓冲区 + destroy_buffer(end_.node + 1, new_end.node); + throw; // 重新抛出异常 + } } - } - else if (position.cur == end_.cur) - { - require_capacity(n, false); - auto new_end = end_ + n; - try + else // 如果位置在中间 { - mystl::uninitialized_copy(first, last, end_); - end_ = new_end; + // 复制插入元素 + copy_insert(position, first, last, n); } - catch (...) - { - if(new_end.node != end_.node) - destroy_buffer(end_.node + 1, new_end.node); - throw; - } - } - else - { - copy_insert(position, first, last, n); - } } -// require_capacity 函数 +// 要求容量 template void deque::require_capacity(size_type n, bool front) { - if (front && (static_cast(begin_.cur - begin_.first) < n)) - { - const size_type need_buffer = (n - (begin_.cur - begin_.first)) / buffer_size + 1; - if (need_buffer > static_cast(begin_.node - map_)) - { - reallocate_map_at_front(need_buffer); - return; - } - create_buffer(begin_.node - need_buffer, begin_.node - 1); - } - else if (!front && (static_cast(end_.last - end_.cur - 1) < n)) - { - const size_type need_buffer = (n - (end_.last - end_.cur - 1)) / buffer_size + 1; - if (need_buffer > static_cast((map_ + map_size_) - end_.node - 1)) - { - reallocate_map_at_back(need_buffer); - return; - } - create_buffer(end_.node + 1, end_.node + need_buffer); - } + if (front && (static_cast(begin_.cur - begin_.first) < n)) // 如果在前面需要额外的容量 + { + // 计算需要的缓冲区数量 + const size_type need_buffer = (n - (begin_.cur - begin_.first)) / buffer_size + 1; + if (need_buffer > static_cast(begin_.node - map_)) // 如果当前映射空间不足 + { + // 在前面重新分配映射空间 + reallocate_map_at_front(need_buffer); + return; + } + // 创建缓冲区 + create_buffer(begin_.node - need_buffer, begin_.node - 1); + } + else if (!front && (static_cast(end_.last - end_.cur - 1) < n)) // 如果在后面需要额外的容量 + { + // 计算需要的缓冲区数量 + const size_type need_buffer = (n - (end_.last - end_.cur - 1)) / buffer_size + 1; + if (need_buffer > static_cast((map_ + map_size_) - end_.node - 1)) // 如果当前映射空间不足 + { + // 在后面重新分配映射空间 + reallocate_map_at_back(need_buffer); + return; + } + // 创建缓冲区 + create_buffer(end_.node + 1, end_.node + need_buffer); + } } -// reallocate_map_at_front 函数 +// 在前面重新分配映射空间 template void deque::reallocate_map_at_front(size_type need_buffer) { - const size_type new_map_size = mystl::max(map_size_ << 1, - map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); - map_pointer new_map = create_map(new_map_size); - const size_type old_buffer = end_.node - begin_.node + 1; - const size_type new_buffer = old_buffer + need_buffer; - - // 另新的 map 中的指针指向原来的 buffer，并开辟新的 buffer - auto begin = new_map + (new_map_size - new_buffer) / 2; - auto mid = begin + need_buffer; - auto end = mid + old_buffer; - create_buffer(begin, mid - 1); - for (auto begin1 = mid, begin2 = begin_.node; begin1 != end; ++begin1, ++begin2) - *begin1 = *begin2; - - // 更新数据 - map_allocator::deallocate(map_, map_size_); - map_ = new_map; - map_size_ = new_map_size; - begin_ = iterator(*mid + (begin_.cur - begin_.first), mid); - end_ = iterator(*(end - 1) + (end_.cur - end_.first), end - 1); + // 计算新的映射大小，至少为当前大小的两倍，或者当前大小加上需要的缓冲区数量和初始大小 + const size_type new_map_size = mystl::max(map_size_ << 1, map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); + // 创建新的映射空间 + map_pointer new_map = create_map(new_map_size); + // 计算当前使用的缓冲区数量 + const size_type old_buffer = end_.node - begin_.node + 1; + // 计算新的缓冲区数量 + const size_type new_buffer = old_buffer + need_buffer; + + // 在新的映射空间中分配缓冲区 + auto begin = new_map + (new_map_size - new_buffer) / 2; // 计算新的开始位置 + auto mid = begin + need_buffer; // 计算中间位置 + auto end = mid + old_buffer; // 计算新的结束位置 + // 创建新的缓冲区 + create_buffer(begin, mid - 1); + // 将旧的缓冲区指针复制到新的映射空间 + for (auto begin1 = mid, begin2 = begin_.node; begin1 != end; ++begin1, ++begin2) + *begin1 = *begin2; + + // 更新数据 + // 释放旧的映射空间 + map_allocator::deallocate(map_, map_size_); + // 更新映射指针 + map_ = new_map; + // 更新映射大小 + map_size_ = new_map_size; + // 更新开始迭代器 + begin_ = iterator(*mid + (begin_.cur - begin_.first), mid); + // 更新结束迭代器 + end_ = iterator(*(end - 1) + (end_.cur - end_.first), end - 1); } -// reallocate_map_at_back 函数 +// 在后面重新分配映射空间 template void deque::reallocate_map_at_back(size_type need_buffer) { - const size_type new_map_size = mystl::max(map_size_ << 1, - map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); - map_pointer new_map = create_map(new_map_size); - const size_type old_buffer = end_.node - begin_.node + 1; - const size_type new_buffer = old_buffer + need_buffer; - - // 另新的 map 中的指针指向原来的 buffer，并开辟新的 buffer - auto begin = new_map + ((new_map_size - new_buffer) / 2); - auto mid = begin + old_buffer; - auto end = mid + need_buffer; - for (auto begin1 = begin, begin2 = begin_.node; begin1 != mid; ++begin1, ++begin2) - *begin1 = *begin2; - create_buffer(mid, end - 1); - - // 更新数据 - map_allocator::deallocate(map_, map_size_); - map_ = new_map; - map_size_ = new_map_size; - begin_ = iterator(*begin + (begin_.cur - begin_.first), begin); - end_ = iterator(*(mid - 1) + (end_.cur - end_.first), mid - 1); + // 计算新的映射大小，至少为当前大小的两倍，或者当前大小加上需要的缓冲区数量和初始大小 + const size_type new_map_size = mystl::max(map_size_ << 1, map_size_ + need_buffer + DEQUE_MAP_INIT_SIZE); + // 创建新的映射空间 + map_pointer new_map = create_map(new_map_size); + // 计算当前使用的缓冲区数量 + const size_type old_buffer = end_.node - begin_.node + 1; + // 计算新的缓冲区数量 + const size_type new_buffer = old_buffer + need_buffer; + + // 在新的映射空间中分配缓冲区 + auto begin = new_map + ((new_map_size - new_buffer) / 2); // 计算新的开始位置 + auto mid = begin + old_buffer; // 计算中间位置 + auto end = mid + need_buffer; // 计算新的结束位置 + // 将旧的缓冲区指针复制到新的映射空间 + for (auto begin1 = begin, begin2 = begin_.node; begin1 != mid; ++begin1, ++begin2) + *begin1 = *begin2; + // 创建新的缓冲区 + create_buffer(mid, end - 1); + + // 更新数据 + // 释放旧的映射空间 + map_allocator::deallocate(map_, map_size_); + // 更新映射指针 + map_ = new_map; + // 更新映射大小 + map_size_ = new_map_size; + // 更新开始迭代器 + begin_ = iterator(*begin + (begin_.cur - begin_.first), begin); + // 更新结束迭代器 + end_ = iterator(*(mid - 1) + (end_.cur - end_.first), mid - 1); } - // 重载比较操作符 template bool operator==(const deque& lhs, const deque& rhs) { - return lhs.size() == rhs.size() && - mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); + // 比较大小 + return lhs.size() == rhs.size() && + // 比较元素 + mystl::equal(lhs.begin(), lhs.end(), rhs.begin()); } template bool operator<(const deque& lhs, const deque& 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()); } template bool operator!=(const deque& lhs, const deque& rhs) { - return !(lhs == rhs); + // 不等于 + return !(lhs == rhs); } template bool operator>(const deque& lhs, const deque& rhs) { - return rhs < lhs; + // 大于 + return rhs < lhs; } template bool operator<=(const deque& lhs, const deque& rhs) { - return !(rhs < lhs); + // 小于等于 + return !(rhs < lhs); } template bool operator>=(const deque& lhs, const deque& rhs) { - return !(lhs < rhs); + // 大于等于 + return !(lhs < rhs); } // 重载 mystl 的 swap template void swap(deque& lhs, deque& rhs) { - lhs.swap(rhs); + // 调用 deque 的 swap 函数 + lhs.swap(rhs); } } // namespace mystl