STL运用的C++技术（5）——重载操作符

       STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文介绍重载操作符。主要参考了《C++ Primer》和《STL源码剖析》。

       重载操作符是具有特殊名称的函数：保留了operator后接需定义的操作符符号。这是《C++ Primer》中的定义。在STL中重载操作符主要用在两个地方，一个是迭代器中，另一个是算法中。本文介绍在迭代器中的应用，下篇介绍在算法中的应用。在本系列博文中，多次提到迭代器，不愧是STL的关键所在。迭代器就像是各种容器对象的智能指针，这仅仅是我的理解。指针的各种行为中常见的有解引用操作符（*）、箭头操作符（->）、自增、自减等。对于容器来说，必须重载这些操作符，以适应自身的指针行为。重载这些操作符，迭代器责无旁贷。看一段STL的源码，做了些修改，更清楚一些。

//结点定义，双向链表
template <class T>
struct List_node {
	List_node* next;
	List_node* prev;
	T data;
};
//链表的迭代器
template<class T, class Ref, class Ptr>
class List_iterator
{
public:
	List_node<T> *node;
	void Incr() { node = node->next; }
	void Decr() { node = node->prev; }
public:
	typedef T value_type;
	typedef Ptr pointer;
	typedef Ref reference;
	typedef size_t                     size_type;
	typedef ptrdiff_t                  difference_type;
	typedef bidirectional_iterator_tag iterator_category;

	typedef List_iterator<T, T&, T*>             iterator;        //迭代器
	typedef List_iterator<T, const T&, const T*> const_iterator;
	typedef List_iterator<T, Ref, Ptr>           self;
	
	List_iterator(List_node<T>* x): node(x) {}     //接受链表结点的构造函数，很管用
	List_iterator() {}
	reference operator*() const { return node->data; }                        //解引用重载
	pointer operator->() const { return &(operator*()); }                     //箭头重载
	self& operator++() { this->Incr(); return *this; }                        //前增重载
    self operator++(int) { self tmp = *this; this->Incr(); return tmp; }      //后增重载
	self& operator--() { this->Decr(); return *this; }                        //前减重载
	self operator--(int) { self tmp = *this; this->Decr(); return tmp; }      //后减重载
	bool operator==(const List_iterator& x) const { return node == x.node; }  //相等重载
	bool operator!=(const List_iterator& x) const { return node != x.node; }  //不相等重载
};

      上面这段代码展现了这些操作符是如何被重载。其实这是个双向链表的迭代器定义，有自增和自减。再进一步，那么链表如何使用上述定义的迭代器呢？下面给出链表的定义，只取STL链表的部分功能，同时给出了测试用例。已在VS2008下测试通过。

#include <iostream>
using namespace std;

//结点定义，双向链表，把上面的代码拷贝下来即可
//链表的迭代器，把上面的代码拷贝下来即可

//资源分配器
class MyAlloc
{
};
//链表定义
template <class T, class Alloc = MyAlloc >
class List {
public:      
	typedef List_node<T> list_node; //结点类型
	typedef list_node* list_type;   //结点指针

    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

	typedef List_iterator<T, T&, T*>             iterator; //迭代器
	typedef List_iterator<T, const T&, const T*> const_iterator;
public:
	List() { node = get_node(); node->next = node; node->prev = node; } //构造哨兵结点
	~List() { clear(); }  
	//返回类型要求是iterator，而实际返回的是结点指针，为什么可以呢？关键在于List_iterator有一个接受结点指针的构造函数
	iterator begin()             { return node->next; } 
    const_iterator begin() const { return node->next; }
    iterator end()               { return node; }
    const_iterator end() const   { return node; }
	bool empty() const { return node->next == node; }
	reference front() { return *begin(); }
	const_reference front() const { return *begin(); }
	reference back() { return *(--end()); }
	const_reference back() const { return *(--end()); }
	void push_front(const T& x) { insert(begin(), x); }
	void push_back(const T& x) { insert(end(), x); }
	void pop_front() { erase(begin()); }
	void pop_back() {  iterator tmp = end(); erase(--tmp); }
	//插入结点
	void insert(iterator pos, const T &x) {            
		list_type tmp = get_node();
		tmp->data = x;
		tmp->next = pos.node; 
		tmp->prev = pos.node->prev;
		(pos.node->prev)->next = tmp;
		pos.node->prev = tmp;
	}
	//删除结点
	iterator erase(iterator pos) { 
		list_type next_node = pos.node->next;
		list_type prev_node = pos.node->prev;
		prev_node->next = next_node;
		next_node->prev = prev_node;
		put_node(pos.node);
		return next_node;
	}
	//清除所有结点
	void clear() {
		list_type cur = node->next;
		while(cur != node)
		{
			list_type tmp = cur;
			cur = cur->next;
			put_node(tmp);
		}
		node->next = node;
		node->prev = node;
	}
private:
	list_type node;
	list_type get_node() { return new list_node; }      //分配空间
	void put_node(list_type p) { delete p; p = NULL; }  //释放空间
};
//测试用例
int main()
{
	List<int> l;
	l.push_back(1);
	l.push_back(2);
	cout<<l.front()<<' '<<l.back()<<endl; //1 2
	l.push_front(3);
	l.push_front(4);
	cout<<l.front()<<' '<<l.back()<<endl; //4 2
	l.pop_back();
	l.pop_front();
	cout<<l.front()<<' '<<l.back()<<endl; //3 1	 
	cout<<l.empty()<<endl;  //0
	l.clear();
	cout<<l.empty()<<endl;  //1
	return 0;
}

       上面这两段程序已经给出了链表的部分功能，同时看到了迭代器的运用以及重载操作符的实现。搞清楚了以上代码，再去看STL的源代码，可能会轻松一点吧，大同小异，核心的结构基本上都是这样的。

       本人享有博客文章的版权，转载请标明出处 http://blog.csdn.net/wuzhekai1985