[GeekBand][C++ STL与泛型编程]第八周笔记

容器deque

C++ STL容器deque和vector很类似，也是采用动态数组来管理元素。
使用deque之前需包含头文件：

#include

它是定义在命名空间std内的一个class template：

template
class _Ax = allocator<_Ty> >
class deque;

第一个template参数用来表示元素型别，第二个可有可无，指定内存模型。一般使用默认的内存模型。

与vector不同的是deque的动态数组首尾都开放，因此能够在首尾进行快速地插入和删除操作。

deque是一种分段连续的容器，特点是双向开口，可以认为它是一段连续的内存空间，不仅可以向前方增加内存空间，也可以向后方增加内存空间。
在实际内存中实现双向扩充是比较复杂的事情，那么deque中是如何实现的呢？deque通过一个控制器来串联一系列的缓冲器（buffer），从而达到逻辑上的连续效果。

deque的内存管理示意图，如下图所示：

deque.png

deque是通过一个vector在维护自身的控制器，在控制器中存储的是指向buffer的指针，因此我们需要用一个指向指针的指针来指向这个vector的地址。
deque能在逻辑上实现内存连续，最关键的是iterator在起作用。迭代器运行到边界的时候，都需要检测是否到边界，然后通过回到控制buffer的那个vector来管理边界的buffer了。在iterator中，cur、first、last和node分别指向了用户使用时的当前的数据，first指向了buffer的第一块空间，last指向了buffer之后那个不在buffer中的空间，而node指向了控制buffer的指针序列中的实际位置
deque的源代码如下所示（参考课程PPT）：

deque_code.png

deque iterator的源代码如下所示：

deque_iterator.png

deuqe的插入问题：

元素插入的时候因为是按顺序排列，如果插入元素不在两头在中间，会改变其他元素的位置，如果插入点距离前段比较近，那么移动前段比较合适，效率较高；
如果插入点距离后端比较近，那么将插入点之后的元素向后移动比较快。
deque insert函数的源代码如下：

iterator insert(iterator postion, const value_type& x){
if(postion.cur == start.cur)  //如果安插点是deque的最前端
{
push_front(x);  //直接使用push_front
return start;
}
else if(postion.cur == finish.cur)  //如果安插点是deque的最末位
{
push_back(x);  //直接交给push_back
iterator tmp = finish;
--tmp;
return tmp;
}
else
{
return insert_aux(postion, x);
}
}

template

typename deque::iterator_deque:: itert_aux(iterator pos, const value_type& x){
difference_type index = pos - start;    //安插点之前的元素个数
value_type x_copy = x;
if(index < size() / 2){  //如果安插点之前的元素较少
push_front(front());  //在最前端加入第一个元素同值的元素
.......
copy(front2, pos1, front1);  //元素搬移
}
else {    //安插点之后的元素较少
push_back(back());//在尾端加入最末元素同值的元素
......
copy_backward(pos, back2, back1);//元素搬移
}
*pos = x_copy;//在安插点上设定新值
return pos;
}

deque如何模拟连续空间，全是的确iterators的功劳
具体代码如下：

reference operator[](size_type n)
{
return start[difference_type(n)];
}
reference front()
{
return *start;
}
reference back()
{
iterator tmp = finish;
--tmp;
return *tmp;
}
size_type size() const
{
return finish - start;
}
bool empty() const
{
return finish == start;
}
reference operator* () const
{
return *cur;
}
pointer operator->() const
{
return &(operator*());
}
//两个iterator之间的距离相当于
//（1）两个iterator之间的buffer的总长度+
//（2）itr至buffer末尾的长度+
//（3）x至buffer开头的长度

difference_type

operator- (const self& x) const
{
return difference_type(buffer_size()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
//buffer size * 首尾buffer之间的buffer之间的数量 + 末尾（当前）buffer的元素量 + 起始buffer的元素量
}
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;
}
void set_node(map_pointer new_node)
{
node = new_node;
first = *new_node;
last = first + difference_type(buffer_size));
}
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;
//切换至正确的的缓存区
set_node(node + node_offset);
cur = first + (offset - node_offset * difference_type(buffser_size());
}
return *this;
}
operator+(difference_type n) const
{
self tmp = *this;
return tmp += n;
}
self& operator-=(difference_type n)
{
return *this += - n;
}
self operator-(difference_type n)
{
self tmp = *this;
return tmp -= n;
}
reference operator[] (difference_type n)const
{
return *(*this + n);
}

GNU 4.9版本中实现的dequeUML图，如下图所示：

deque_gcc.png

衍生

deque和vector的不同之处：

两端都能够快速插入和删除元素。vector只能在尾端进行。
deque的元素存取和迭代器操作会稍微慢一些。因为deque的内部结构会多一个间接过程。
迭代器是特殊的智能指针，而不是一般指针。它需要在不同的区块之间跳转。
deque可以包含更多的元素，其max_size可能更大。因为不止使用一块内存。
不支持对容量和内存分配时机的控制。
注意：在除了首尾两端的其他地方插入和删除元素，都将会导致指向deque元素的任何pointers、references、iterators失效。不过，deque的内存重分配优于vector。因为其内部结构显示不需要复制所有元素。
deque的内存区块不再被使用时，会被释放。deque的内存大小是可缩减的。不过，是不是这么做以及怎么做由实作版本定义。

deque和vector相似的特性：

在中间部分插入和删除元素相对较慢，因为所有元素都要被移动。
迭代器属于随即存取迭代器。

最好采用deque的情形：

需要在两端插入和删除元素。
无需引用容器内的元素。
3.要求容器释放不再使用的元素。

容器 queue

queue模版类的定义在头文件中
queue与stack模版非常类似，queue模版也需要定义两个模版参数，一个是元素类型，一个是容器类型，元素类型是必要的，容器类型是可选的，默认为dqueue类型。
定义queue对象的示例代码如下：

queueq1;
queueq2;

queue的基本操作有：

入队：如q.push(x):将x元素接到队列的末端；
出队：如q.pop() 弹出队列的第一个元素，并不会返回元素的值；
访问队首元素：如q.front()
访问队尾元素，如q.back();
访问队中的元素个数，如q.size();

优先队列
在头文件中，还定义了一个非常有用的模版类priority_queue(优先队列），优先队列与队列的差别在于优先队列不是按照入队的顺序出队，而是按照队列中元素的优先权顺序出队（默认为大者优先，也可以通过指定算子来指定自己的优先顺序）。
priority_queue模版类有三个模版参数，元素类型，容器类型，比较算子。其中后两个都可以省略，默认容器为vector，默认算子为less，即小的往前排，大的往后排（出队时序列尾的元素出队）。
定义priority_queue对象的示例代码如下：

priority_queueq1;
priority_queue >q2;
priority_queue，greater >q3;//定义小的先出队

priority_queue的基本操作均与queue相同

初学者在使用priority_queue时，最困难的可能就是如何定义比较算子了。如果是基本数据类型，或已定义了比较运算符的类，可以直接用STL的less算子和greater算子——默认为使用less算子，即小的往前排，大的先出队。如果要定义自己的比较算子，方法有多种，这里介绍其中的一种：重载比较运算符。优先队列试图将两个元素x和y代入比较运算符(对less算子，调用xy)，若结果为真，则x排在y前面，y将先于x出队，反之，则将y排在x前面，x将先出队。
容器queue是以deque为底层结构实现的，具体代码如下：

template >
class queue
{
............
public:
typedef typename Sequence::value_type value_type
typedef typename Sequence::size_type size_type
typedef typename Sequence::reference reference;
typedef typename Sequence::const_reference const_reference;
protected:
Sequence c;  //底层容器
public:
bool empty() const{return c.empty();}
size_type size() const{return c.size();}
reference front() const {return c.front();}
const_reference front() const{ return c.front();}
reference back(){return c.back(); }
const_reference back() const {return c.back();}
void push (const value_type& x){ c.push_back(); }
void pop(){c.pop.front();}
}

容器 stack

容器stack也是以deque为底层结构实现的，需要注意的是queue和stack都不允许遍历，也不提供iterator，具体代码如下：

template >
class stack
{
............
public:
typedef typename Sequence::value_type value_type
typedef typename Sequence::size_type size_type
typedef typename Sequence::reference reference;
typedef typename Sequence::const_reference const_reference;
protected:
Sequence c;  //底层容器
public:
bool empty() const{return c.empty();}
size_type size() const{return c.size();}
reference top() const {return c.back();}
const_reference top() const{ return c.back();}
void push (const value_type& x){ c.push_back(); }
void pop(){c.pop.back();}
}

容器 rb_tree

Red-Black tree（红黑树）是平衡二元搜寻树（balanced Binary search tree）中常被使用的一种。
平衡二元搜寻树的特征：排列规律，有利于search和insert，并保持适度平衡，无任何节点过深。

rb-tree.png

红黑树的实现代码：

rb_tree_code.png

容器 set，multiset

set_multiset.png

需要包含头文件

#include

set和multiset都是定义在std空间里的类模板：

template
class _Pr = less<_Kty>,
class _Alloc = allocator<_Kty> >
class set

template
class _Pr = less<_Kty>,
class _Alloc = allocator<_Kty> >
class multiset

只要是可复赋值、可拷贝、可以根据某个排序准则进行比较的型别都可以成为它们的元素。第二个参数用来定义排序准则。缺省准则less是一个仿函数，以operator<对元素进行比较。
所谓排序准则，必须定义strict weak ordering，其意义如下：

必须使反对称的。
对operator<而言，如果x
必须使可传递的。
对operator<而言，如果x
必须是非自反的。
对operator<而言，x
因为上面的这些特性，排序准则可以用于相等性检验，就是说，如果两个元素都不小于对方，则它们相等。

set和multiset的功能

和所有关联式容器类似，通常使用平衡二叉树完成。事实上，set和multiset通常以红黑树实作而成。
自动排序的优点是使得搜寻元素时具有良好的性能，具有对数时间复杂度。但是造成的一个缺点就是：
不能直接改变元素值。因为这样会打乱原有的顺序。
改变元素值的方法是：先删除旧元素，再插入新元素。
存取元素只能通过迭代器，从迭代器的角度看，元素值是常数。
容器set的实现代码：

template , class Alloc = alloc>
class set{
public:
//typedefs:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
typedef rb_tree rep_type;
rep_type t;
public:
typedef typename rep_type::const_iterator iterator;
...
//set的所有操作，都调用底层rb_tree的函数，从这点看来，set实际应该为container adapter
}

容器multiset的实现代码如下：

multiset_code.png

容器 map和multimap

map_multimap.png

map的实现代码如下：

map_code.png

multimap实现代码如下：

multi_map.png

容器map独特的operator[]

map_operator.png

衍生：

map和multimap容器跟set和multiset容器非常相似，包括外部接口和内部结构上。不同之处就是set和multiset容器是以单个对象为管理元素，而map和multimap容器是以pair为管理元素。map和multimap容器中元素同时是自动排序，它们排序的依据是各个元素的key值。
map和multimap容器在内部结构上通常也采用平衡二叉树(balanced binary tree)，拥有跟set和multiset一样的能力和操作。不同之处就是元素形式上，另外map和multimap容器可以作为关联数组使用。
在map或者multimap容器中查找特定值的元素，除了传统的遍历元素查找外，还可以使用通用算法来查找，但要自己设计函数对象