Boolan STL与泛型编程 第三周笔记

   

1.容器deque

deque是一种分段连续的容器，特点是双向开口，可以认为它是一段连续的内存空间，不仅可以向前方增加内存空间，也可以向后方增加内存空间。

在实际内存中实现双向扩充是比较复杂的事情，那么deque中是如何实现的呢？deque通过一个控制器来串联一系列的缓冲器（buffer），从而达到逻辑上的连续效果。

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

deque是通过一个vector在维护自身的控制器，在控制器中存储的是指向buffer的指针，因此我们需要用一个指向指针的指针来指向这个vector的地址。

deque能在逻辑上实现内存连续，最关键的是iterator在起作用。迭代器运行到边界的时候，都需要检测是否到边界，然后通过回到控制buffer的那个vector来管理边界的buffer了。在iterator中，cur、first、last和node分别指向了用户使用时的当前的数据，first指向了buffer的第一块空间，last指向了buffer之后那个不在buffer中的空间，而node指向了控制buffer的指针序列中的实际位置

deque的源代码如下所示（参考课程PPT）：

deque iterator的源代码如下所示：

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 <class T, class Alloc, size_t BufSize>typename deque<T, Alloc, BufSize>::iterator_deque<T, Alloc, BufSIze>:: 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_typeoperator- (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图，如下图所示：

2.容器 queue

容器queue是以deque为底层结构实现的，具体代码如下：

template <class T, class Sequence = deque<T>>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();}}

3.容器 stack

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

template <class T, class Sequence = deque<T>>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();}}

4.容器 rb_tree

Red-Black tree（红黑树）是平衡二元搜寻树（balanced Binary search tree）中常被使用的一种。

平衡二院搜寻树的特征：排列规律，有利于search和insert，并保持适度平衡，无任何节点过深。

红黑树的实现代码：

5.容器 set，multiset

容器set的实现代码：

template <class Key, class Compare = less<Key>, 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<key_type, value_type, identity<value_type<. key_compare, Alloc> rep_type;     rep_type t; public:      typedef typename rep_type::const_iterator iterator;  ...//set的所有操作，都调用底层rb_tree的函数，从这点看来，set实际应该为container adapter}

容器multiset的实现代码如下：

6.容器 map和multimap

map的实现代码如下：

multimap实现代码如下：

容器map独特的operator[]