STL源码剖析-----__deque_iterator

///计算缓冲区大小（一个缓冲区存放多少个元素），
// 如果 n 不为 0，传回 n，表示 buffer size 由使用者自定。
// 如果 n 为 0，表示 buffer size 使用默认值，那么
//如果sz（元素大小，sizeof(value_type)）小于 512，传回 512 / sz，
//如果sz 不小于 512，传回 1。
inline size_t __deque_buf_size(size_t n, size_t sz)
{
  return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}


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;
///图4.4-2 iterator的node指向map节点，map节点指向缓冲区节点，所以这里是T的二级指针
  typedef T** map_pointer;

  typedef __deque_iterator self;
///first和last是缓冲区的头尾，不是缓冲区已使用头尾
//          first-> |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|<-las
//看set_node函数就知道first和last的指向了
  T* cur
  T* first;
  T* last;
  map_pointer node;
//构造函数
  __deque_iterator(T* x, map_pointer y) 
    : cur(x), first(*y), last(*y + buffer_size()), node(y) {}
  __deque_iterator() : cur(0), first(0), last(0), node(0) {}
  __deque_iterator(const iterator& x)
    : cur(x.cur), first(x.first), last(x.last), node(x.node) {}

  reference operator*() const { return *cur; }
  pointer operator->() const { return &(operator*()); }

	//计算两个迭代器间的距离
	difference_type operator-(const self& x) const {
		//如图4.4-2，例：finish-start
		//x.last - x.cur：start缓冲区内的距离
		//cur-first:finish缓冲区内的距离
		//node - x.node:finish和start在map上的距离，
		//由于start内的距离已经另外算，所以算finish到start后一个node的距离，node - x.node-1
		return difference_type(buffer_size()) * (node - x.node - 1) +
			(cur - first) + (x.last - x.cur);
	}

//前自增
  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) {
  //n可能为负，后移
  //offset:目标位置和first的距离
    difference_type offset = n + (cur - first);
    if (offset >= 0 && offset < difference_type(buffer_size()))
    //目标位置在同一缓冲区
      cur += n;
    else {
    //node_offset:在map上移动的距离
      difference_type node_offset =
        offset > 0 ? offset / difference_type(buffer_size())
                   : -difference_type((-offset - 1) / buffer_size()) - 1;
      //让迭代器指向目标缓冲区
      set_node(node + node_offset);
      //缓冲区内移动的距离
      cur = first + (offset - node_offset * difference_type(buffer_size()));
    }
    return *this;
  }

  self operator+(difference_type n) const {
    self tmp = *this;
    //调用重载operator+=
    return tmp += n;
  }
//n变成-n，调用重载operator+=
  self& operator-=(difference_type n) { return *this += -n; }
 
  self operator-(difference_type n) const {
    self tmp = *this;
    // //调用重载operator-=
    return tmp -= n;
  }
//随机存取
  reference operator[](difference_type n) const { return *(*this + n); }

  bool operator==(const self& x) const { return cur == x.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);
  }
//设定迭代器指向新缓冲区
  void set_node(map_pointer new_node) {
    node = new_node;
    first = *new_node;
    last = first + difference_type(buffer_size());
  }
};

图4.4-2