// __deque_iterator的源碼
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator
{
	typedef __deque_iterator<T, T&, T*>             iterator;
	typedef __deque_iterator<T, const T&, const T*> const_iterator;
	static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); }//buffer_size()用于確定緩沖區(qū)的大小
	typedef random_access_iterator_tag iterator_category;
	typedef T value_type;
	typedef Ptr pointer;
	typedef Ref reference;
	typedef size_t size_type; // size_t 是unsigned 類型,通常用來指明數(shù)組長度
	typedef ptrdiff_t difference_type; // ptrdiff_t 是 signed 整型,通常用來保存兩個指針減法操作的結果
	typedef T** map_pointer;
	typedef __deque_iterator self;
	// 保持與容器的聯(lián)結，是對某一個緩沖區(qū)而言的
	T* cur;       // 此迭代器所指之緩沖區(qū)中的現(xiàn)行元素
	T* first;     // 此迭代器所指之緩沖區(qū)的頭
	T* last;      // 此迭代器所指之緩沖區(qū)的尾（含備用空間）
	map_pointer node;    // 指向管控中心
        ...
}
//deque_buf_size()全局函數(shù)
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));
}
//定義：
//1. 如果n不為0，傳回n，表示buffer size由使用者自定。
//2. 如果n為0，表示buffer size使用默認值，那么：
//    如果sz不小于 512，返回1。
//    如果sz（元素大小，sizeof(value_type)）小于512，傳回512/sz。

void set_node(map_pointer new_node) {
	node = new_node;
	first = *new_node;
	last = first + difference_type(buffer_size());
}
reference operator*() const { return *cur; }
pointer operator->() const { return &(operator*()); }
difference_type operator-(const self& x) const {
	return difference_type(buffer_size()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
}
self& operator++() {
	++cur;        //切換至下個元素
	if (cur == last) {   //如果已達所在緩沖區(qū)的尾端，就切換至下一節(jié)點（亦即緩沖區(qū)）的第一個元素
		set_node(node + 1);
		cur = first;
	}
	return *this;
}
self operator++(int) { //后置式，標準寫法
	self tmp = *this;
	++*this;
	return tmp;
}
self& operator--() {
	if (cur == first) {//如果已達所在緩沖區(qū)的頭端， 就切換至前一節(jié)點（亦即緩沖區(qū)）的最后一個元素
		set_node(node - 1);
		cur = last;
	}
	--cur; //切換至前一個元素
	return *this;
}
self operator--(int) { //后置式，標準寫法
	self tmp = *this;
	--*this;
	return tmp;
}
// 以下實現(xiàn)隨機存取。迭代器可以直接跳躍n個距離
self& operator+=(difference_type n) {
	difference_type offset = n + (cur - first);
	if (offset >= 0 && offset < difference_type(buffer_size()))
		//標的位置在同一緩沖區(qū)內
		cur += n;
	else {
		//標的位置不在同一緩沖區(qū)內
		difference_type node_offset =
			offset > 0 ? offset / difference_type(buffer_size()) : -difference_type((-offset - 1) / buffer_size()) - 1;
		// 切換至正確的節(jié)點（亦即緩沖區(qū)）
		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;
    return tmp += n; //調用operator+=
}
//利用operator+=完成operator-=
self& operator-=(difference_type n) { return *this += -n; }
self operator-(difference_type n) const {
    self tmp = *this;
    return tmp -= n; //調用operator-=
}
//實現(xiàn)隨機存取，迭代器可以直接跳躍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);
}