STL（九）之iterator

C++标准库（九）之iterator

iterator

iterator模式：提供一种方法，使之能依次访问容器内的各个元素，而又不暴露该聚合物内部的表述方式。
STL的中心思想是将算法与数据结构分离，彼此独立设计，最后在用iterator将他们结合在一起，获得最大的适配性。

vector

设计理念

vector是动态空间，随着元素的加入，内部机制会自动扩充空间以容纳新元素。vector的实现技术核心在于：对容器大小的控制以及重新配置时数据的移动效率。
空间配置策略：在原容器无可用空间时，将容器大小扩展为原先的两倍，然后将原先的数据copy，在copy的数据后面构造新元素。
数据移动效率：根据是否为POD类型判断移动数据的成本，并想进一切方法减少数据移动的次数，源码中有详解。

迭代器定义

vector在进行萃取的时候，会使用萃取提供的特化版本：template<typename T> struct iterator_traits<T*> {}

template<typename T,class Alloc=alloc>
class vector
{
    public:
        typedef T value_type;
        typedef value_type* pointer;
        typedef value_type* iterator;
        typedef value_type& reference;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;
    
    protected:
        iterator begin;
        iterator end;        //使用空间的尾部
        iterator end_of_storage;        //可用空间的尾部
};

迭代器失效分析

• 增加/删除当前的iterator，当前iterator后面的iterator都会失效
• 当增加元素的时候，因为扩容，可能会使原先的迭代器全部失效

list

设计理念

SGI STL的list是不仅是双向链表，还是一个环形链表，存在一个额外的尾部结点，遵守STL算法左闭右开的要求。

迭代器定义

template<typename T>
struct __list_node
{
    typedef void* void_pointer;
    void_pointer prev;
    void_pointer next;
    T data;
};

template<typename T,typename ref,typename ptr>
struct __list_iterator
{
    typedef __list_iterator<T,T&,T*> iterator;
    typedef __list_iterator<T,ref,ptr> self;
    typedef bidirectional_iterator_tag iterator_category;
    typedef T value;
    typedef ptr pointer;
    typedef ref reference;
    typedef __list_node<T>* link_type;    
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    link_type node;
    __list_iterator(link_type type) : node(type) {};
    __list_iterator() {};
    __list_iterator(const __list_iterator& iter) : node(iter.node) {};
    
    bool operator==(const self& iter) const  {return iter.node == node;};
    bool operator!=(const self& iter) const {return iter.node != node;};
    reference operator*() const {return ((*node).data;};
    pointer operator->() const {return &(operator*());};
    
    self& operator++()
    {
        node = (link_type)((*node).next);
        return *this;
    }
    
    slef operator++(int)
    {
        self temp = *this;
        ++*this;
        return temp;
    }

    self& operator()
    {
        node = (link_type)((*node).prev);
        return *this;
    }
    
    slef operator++(int)
    {
        self temp = *this;
        --*this;
        return temp;
    }
}

template<typename T,class Alloc=alloc>
class list
{
protected:
    typedef void* _Void_pointer;

public:      
    typedef _Tp value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef _List_node<_Tp> _Node;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

public:
    typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
    typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
}

迭代器失效分析

• 插入或者删除都不会导致迭代器失效

  deque

  

  设计理念

  deque允许在常数时间内对头端的元素进入插入或者删除，因为他是动态的以连续分段的空间组成的，访问的复杂度由迭代器去维护。这里的map是由一小块连续空间，其中每个元素都是指针，指向一小段连续空间，其中每个元素都是指针，指向另一段连续线性空间，成为缓冲区，默认值为512bytes。
  一个deque至少会管理8个节点，最多是“所需节点数+2”。在结点数已经用完的情况下，重新换一个map。
  删除或者插入的方式：如果清除/插入点之前的元素较少，就移动清除点之前的元素；反之，移动清除/插入点之后的元素。

  迭代器定义

  deque是连续分段空间，维持其在“整体连续”假象的任务，落在了迭代器operator++和operator--两个运算子身上。

template <class _Tp, class _Ref, class _Ptr>
struct _Deque_iterator 
{
    typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
    typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
    static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }

    typedef random_access_iterator_tag iterator_category;
    typedef _Tp value_type;
    typedef _Ptr pointer;
    typedef _Ref reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef _Tp** _Map_pointer;

    typedef _Deque_iterator _Self;

    _Tp* _M_cur;
    _Tp* _M_first;
    _Tp* _M_last;
    _Map_pointer _M_node;

    _Deque_iterator(_Tp* __x, _Map_pointer __y) 
    : _M_cur(__x), _M_first(*__y),
      _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
  
    _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
    
    _Deque_iterator(const iterator& __x)
    : _M_cur(__x._M_cur), _M_first(__x._M_first), 
      _M_last(__x._M_last), _M_node(__x._M_node) {}

    reference operator*() const { return *_M_cur; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
    pointer operator->() const { return _M_cur; }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

    difference_type operator-(const _Self& __x) const 
    {
        return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) + (_M_cur - _M_first) + (__x._M_last - __x._M_cur);
    }

    _Self& operator++() 
    {
        ++_M_cur;
        if (_M_cur == _M_last) 
        {
            _M_set_node(_M_node + 1);
            _M_cur = _M_first;
        }   
        return *this; 
    }
    
    _Self operator++(int)  
    {
        _Self __tmp = *this;
        ++*this;
        return __tmp;
    }

    _Self& operator--() 
    {
        if (_M_cur == _M_first) 
        {
        _M_set_node(_M_node - 1);
        _M_cur = _M_last;
        }
        --_M_cur;
        return *this;
    }
    _Self operator--(int) 
    {
        _Self __tmp = *this;
        --*this;
        return __tmp;
    }

    _Self& operator+=(difference_type __n)
    {
        difference_type __offset = __n + (_M_cur - _M_first);
        if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
        _M_cur += __n;
        else 
        {
            difference_type __node_offset = __offset > 0 ? __offset / difference_type(_S_buffer_size()) : -difference_type((-__offset - 1) / _S_buffer_size()) - 1;
            _M_set_node(_M_node + __node_offset);
            _M_cur = _M_first + 
            (__offset - __node_offset * difference_type(_S_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& __x) const { return _M_cur == __x._M_cur; }
    bool operator!=(const _Self& __x) const { return !(*this == __x); }
    bool operator<(const _Self& __x) const 
    {
        return (_M_node == __x._M_node) ? (_M_cur < __x._M_cur) : (_M_node < __x._M_node);
    }
  
    bool operator>(const _Self& __x) const  { return __x < *this; }
    bool operator<=(const _Self& __x) const { return !(__x < *this); }
    bool operator>=(const _Self& __x) const { return !(*this < __x); }

    void _M_set_node(_Map_pointer __new_node) 
    {
        _M_node = __new_node;
        _M_first = *__new_node;
        _M_last = _M_first + difference_type(_S_buffer_size());
    }
};

template <class _Tp, class _Ref, class _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
{
    return __x + __n;
}

template<typename T,typename Alloc=alloc,size_t Bufsize = 0>
class deque
{
    public:
        typedef T value_type;
        typede value_type* pointer;
        typedef size_t size_type;
        typedef __deque_iterator<T,T&,T*,BufSize> iterator;
        
    protected:
        typedef pointer* map_pointer;
        iterator begin;
        iterator end;
        map_iterator map;
        size_type map_size;
}

迭代器失效分析

• 插入时，可能会更换map，使得存在的所有迭代器失效

• 删除时，使当前iterator之后/之前的迭代器失效，根据前后元素量的多少决定。

  set和multiset

  设计理念

  在SGI STL中，set底层使用红黑树完成，set中所有的元素都是自动排列的，在set中：value = key，并且，set中的值不允许修改。
  set与multiset的区别在于使用红黑树的底层插入操作不同：insert_equal()和insert_unique()

  迭代器定义

  迭代器的++和--操作是以中序遍历的过程进行的。

template<typename Key, typename Compare = less<Key>, class Alloc = alloc>
class set
{
    public:
        typedef Key key_type;
        typedef Key value_type;
        typedef rb_tree<key_type,value_type,identity<value_type>,key_compare,Alloc> rep_type; 

        typedef typename rep_type::const_pointer pointer;
        typedef typename rep_type::const_pointer const_pointer;
        typedef typename rep_type::const_reference reference;
        typedef typename rep_type::const_reference const_reference;
        typedef typename rep_type::const_iterator iterator;
        typedef typename rep_type::const_iterator const_iterator;
    
    private:
        rep_type rep;
}

迭代器失效分析

基本上删除和插入操作都不会使迭代器失效。

map和multimap

设计理念

在SGI STL中，map底层使用红黑树完成。所有的元素都会根据元素的键值自动排序。map的所有元素都是pair，同时拥有value可key。
map与multimap的区别在于使用红黑树的底层插入操作不同：insert_equal()和insert_unique()

迭代器定义

迭代器的++和--操作是以中序遍历的过程进行的。

template<typename T1,typename T2>
struct pair
{
    typedef T1 first_type;
    typedef T2 second_type;
    
    T1 first;
    T2 second;
};

template<typename Key,typename Value,typename Compare = less<Key>, class Alloc=alloc>
class map
{
    public:
        typedef Key key_type;
        typedef Value value_type;
        typedef Value mapped_type;
        typedef pair<const Key,Value> value_type;
        typedef Compare key_conpare;

        typedef rb_tree<key_type,value_type,select1st<value_type>,key_compare,Alloc> rep_type;
        
        typedef typename rep_type::pointer pointer;
        typedef typename rep_type::const_pointer const_pointer;
        typedef typaneme rep_type::iterator iterator;
        typedef typaneme rep_type::const_iterator const_iterator;
    private:
        rep_type rep;
};

迭代器失效分析

基本上删除和插入操作不会使迭代器失效。