暑假那会就开始看 STL 源码了,看了不少,空间配置器,vector,list,map 等等,但是都没有总结,现在感觉忘了不少。最近趁上课没事干,把 STL 源码复习复习,今天就看的所谓的双端队列 deque。
一: Deque 概述
- deque 允许常数时间内对头端进行插入或删除操作。
- deque 没有所谓的容量概念,因为它是动态的以分段连续空间组合而成,随时可以增加一段新的空间并链接起来。像 vector 那样 “因旧空间不足而配置重新配置一块更大空间,然后复制元素,再释放旧空间” 这样的事情 deque 是不会发生的。因此,deque 也没有 提供 reserve 方法。(注意:deque 迭代器也存在失效的可能,后面会说)。
二:Deque 的中控器
inline size_t __deque_buf_size(size_t n, size_t sz) //__deque_iterator的构造函数模板参数为:template <class T, class Ref, class Ptr, size_t BufSiz>
{
return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}
三:Deque 的迭代器
- 它必须能够指出分段连续空间(即缓冲区)在哪里,能进行缓冲区内部元素的增添等操作。
- 它必须能够判断自己是否处于缓冲区的边缘,如果是,一旦前进后退就必须跳跃至下一个或上一个缓冲区。
- 为了能够跳跃,deque 必须能够随时掌控管控中心。
- cur 指针:cur 指针指向此迭代器所指向缓冲区的 current 元素,用于支持数据操作。
- first 指针:first 指针指向所指缓冲区的头,用来控制头部边界
- last 指针:last 指针指向所指缓冲区的尾部下一个,实际上已经指向缓冲区之外,符合 [ first, last)。
- node 指针:node 指针指向管控中心,当元素到达缓冲区边沿时,元素需要跳到下一缓冲区,这是就要和 node 配合了。
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
static size_t buffer_size() {return __deque_buf_size(BufSiz, sizeof(T)); }
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T** map_pointer;
typedef __deque_iterator self;
T* cur;
T* first;
T* last;
map_pointer node; //T**类型
...
}
//跳跃缓冲区,可以前进也可以后退
void set_node(map_pointer new_node) {
node = new_node; //node指针指向要跳跃的node
first = *new_node; //改变 first
last = first + difference_type(buffer_size()); //改变last
}
};
下面将会给出 iterator 支持的常见操作,不过要注意的是,它的任何 operator 重载都是围绕 cur 指针的,例如 operaror++,并不是说迭代器+1就到了下一个结点,其意义实际上是迭代器内部的 cur 指针进行了+1操作,向后移动了 T 类型的举例。 所以可以说
cur 指针是迭代器唯一的身份认证,cur 不一样就说明不是同一个迭代器!
reference operator*() const { return *cur; }
pointer operator->() const { return &(operator*()); }
difference_type operator-(const self& x) const { //迭代器位置之差,就是cur之差,也就是中间缓冲区长度,加上它们分别所在缓冲区实际元素长度
return difference_type(buffer_size()) * (node - x.node - 1) +
(cur - first) + (x.last - x.cur);
}
self& operator++() { //前置++,进行 cur 的++操作,如果等于 last(last 指向缓冲区外),跳到下一个缓冲区
++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) { // +=
difference_type offset = n + (cur - first); //首先计算总长度
if (offset >= 0 && offset < difference_type(buffer_size())) //如果加上之后还在本缓冲区内
cur += n; //直接 += 原始指针
else { //目标位置不再同一缓冲区内
difference_type node_offset =
offset > 0 ? offset / difference_type(buffer_size()) //不同缓冲区需要跳跃
: -difference_type((-offset - 1) / buffer_size()) - 1;//>0向后跳,<0向前跳,向前跳注意不能直接除bufsize,否则值不足bufsize,计算结果为0
set_node(node + node_offset); //切换到正确结点
cur = first + (offset - node_offset * difference_type(buffer_size())); //切换正确元素(核心还是要处理 cur 吧)
}
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& x) const { return cur == x.cur; } // 呵呵,注意判断的是 cur 相等不相等,它决定是否是统一迭代器
bool operator!=(const self& x) const { return !(*this == x); }
bool operator<(const self& x) const {
return (node == x.node) ? (cur < x.cur) : (node < x.node); // 判断 cur
}
四:Deque 的数据结构
template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque {
public: // Iterators
typedef __deque_iterator<T, const T&, const T&, BufSiz> const_iterator;
protected: // Internal typedefs
typedef pointer* map_pointer;
typedef simple_alloc<value_type, Alloc> data_allocator;
typedef simple_alloc<pointer, Alloc> map_allocator;
static size_type initial_map_size() { return 8; }
protected: // Data members
iterator start;
iterator finish;
map_pointer map;
size_type map_size;
public: // Basic accessors
iterator begin() { return start; }
...
}其中包含了迭代器、默认的两个空间配置器(用来配置数据和map),以及一个 start 迭代器和 finish 迭代器:
deque 构造好可能是这样的:
deque(long n, const value_type& value)
: start(), finish(), map(0), map_size(0)
{
fill_initialize(n, value);
}
template <class T, class Alloc, size_t BufSize>
void deque<T, Alloc, BufSize>::fill_initialize(size_type n,
const value_type& value) {
create_map_and_nodes(n);
map_pointer cur;
__STL_TRY {
for (cur = start.node; cur < finish.node; ++cur)
uninitialized_fill(*cur, *cur + buffer_size(), value);
uninitialized_fill(finish.first, finish.cur, value);
}
}该函数会调用 create_map_and_nodes() 函数进行创建过程,以及用 uninitialized_fil() 函数取填充值,我们只看前者:
template <class T, class Alloc, size_t BufSize>
void deque<T, Alloc, BufSize>::create_map_and_nodes(size_type num_elements) {
size_type num_nodes = num_elements / buffer_size() + 1; //如果结点刚好整除,会多分配一个结点。
map_size = max(initial_map_size(), num_nodes + 2); //默认最小8个结点,大于8个,则分配num+2个,因为前后预留一个,翻遍扩充
map = map_allocator::allocate(map_size);
//以上培植出一个 "具有map_size个节点的"map
//以下令nstart和nfinish指向map数组全部结点的中央区段
//保持在最中央,可使头尾两端扩充能量一样大,每个节点可对应一个缓冲区
map_pointer nstart = map + (map_size - num_nodes) / 2;
map_pointer nfinish = nstart + num_nodes - 1;
map_pointer cur;
__STL_TRY {
//为mep内的每个 现用 节点配置缓冲区,注意前后预留的不会配置缓冲区,所以缓冲区加起来就是deque的可用空间
//可用空间(最后一个可用空间可能留有一些余裕澹?
for (cur = nstart; cur <= nfinish; ++cur)
*cur = allocate_node();
}
start.set_node(nstart);
finish.set_node(nfinish);
start.cur = start.first;
finish.cur = finish.first + num_elements % buffer_size();
//前面说过,如果刚好整除,会多配一个节点
//此时即令cur指向这多配的一个节点起始处
}
110



被折叠的 条评论
为什么被折叠?



