STL之deque（二）

      下面是deque迭代器的几个关键行为。由于迭代器内对各种指标运算都做了重载化动作，所以各种指标运算如加，减，前进，后退...都不能直观视之。其中最重点的关键就是：一旦行进时遇到缓冲区边缘，要特别当心，视前进或后退而定，可能需要呼叫set_node()跳一下缓冲区。

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)    // 如果已达到缓冲区的尾端
	{
	    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;
}

// 以下实现随机存取。迭代器可以直接跳跃n个距离
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()) - 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;
	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);
}