STL之迭代器

看的越多，好像关于迭代器也就越难写了，呵呵不过，还是做个记录，聊以自慰吧

1、首先迭代器是一种广义的指针，一个数组也同样可以作为一种迭代器的具象，迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器不仅仅是指针，因此你不能认为他们一定具有地址值。例如，一个数组索引，也可以认为是一种迭代器。

2、迭代器在STL中共有几种类型：

·        Input iterators 提供对数据的只读访问。
·        Output iterators 提供对数据的只写访问
·        Forward iterators 提供读写操作，并能向前推进迭代器。只能进行++操作
·        Bidirectional iterators提供读写操作，并能向前和向后操作。基类是Bidirectional iterators可以进行++  --操作
·        Random access iterators提供读写操作，并能在数据中随机移动。基类是Bidirectional iterators,可以进行+=  -=操作

这是五种迭代器类型，但是我们知道vector  dequeue   list map等等，的泛型迭代器，会有不同的实现，也即上述迭代器种类只是概念性质的分类，比如vector的iterator的实现其就在vector.h文件当中而不是iterator.h文件当中，该文件的作用，笔者尚未弄清，限于能力请见谅！！！

在vector的iterator类型即为Random access iterators类型，随机访问的迭代器

在iterator模板类中，定义了5个成员类别：value_type,difference_type pointer，reference, iterator_category，用作所有其它迭代器的基类。

    back_insert_iterator模板类，是一种输出迭代器，用于在容器对象的尾部追加新的元素。该迭代器被赋值时，调用了容器对象的push_back()成员函数。该迭代器的自增操作实际上为空操作。
    back_inserter模板函数，用于方便地由一个容器构造出back_insert_iterator
 

  front_insert_iterator模板类，是一种输出迭代器，用于在容器对象的头部插入新的元素。该迭代器被赋值时，调用了容器对象的push_front()成员函数。该迭代器的自增操作实际上为空操作。
    front_inserter模板函数，用于方便地由一个容器构造出front_insert_iterator
    insert_iterator模板类，是一种输出迭代器，用于在容器对象的指定位置插入新的元素。该迭代器被赋值时，调用了容器对象的insert()成员函数。该迭代器的自增操作实际上为空操作。
    insert_inserter模板函数，用于方便地由一个容器构造出insert_iterator

 

在STL定义的容器中，string，vector与deque提供了随机访问迭代器，list、set、multiset、map、multimap提供了双向迭代器。

迭代器根据的是23种设计模式中的迭代器模式，该模式的主要特点就是隐藏内部细节，继而可以遍历整个中心数据，而Iterator就是根据传入数据进行遍历的！！！！迭代器主要有两个，一者迭代器，也即遍历所有内容的广义迭代器，二者容器，容器是广义的数组，我们需要得到这个容器的内容的指针，然后会在迭代器中记录当前指针记录读取容器中的位置，需要记录两个，一个是容器的实力对象，二者记录容器元素的指针，进行移动

进行遍历。其C++代码实现迭代器如下：

#include <iostream>
using namespace std;
template<class T>
class Iterator_m
{
public:
	virtual T* First() = 0;
	virtual T* Next() = 0;
	virtual bool isDone() = 0;
};

template<class T>
class TList
{
private:
	T* m_list;
	int max_num;
	int m_cur_num;
public:
	T* getFirst()
	{
		return m_list;
	}
	int getNum()
	{
		return m_cur_num;
	}
	void Append(T m)
	{
		if (m_cur_num == max_num)
		{
			//当前空间已经使用完了，开辟新的空间，首先进行
			T* new_list = new T[max_num * 2];
			for (int i = 0; i < max_num; i++)
			{
				new_list[i] = m_list[i];
				delete m_list;
				m_list = new_list;
			}
			max_num *= 2;
		}
		m_list[m_cur_num] = m;
		m_cur_num++;
	}
	TList()
	{
		m_cur_num = 0;
		max_num = 24;
		m_list = new T[max_num];
	}
	Iterator_m<T>* createIterator()
	{
		return 	new ConcerteIterator<T>(this);
	}
};
template<class T>
class ConcerteIterator :public Iterator_m<T>
{
private:
	TList<T>* m_hinstance;
	T* m_element;
	int m_cur_pos;
public:
	ConcerteIterator(TList<T>*m)
	{
		m_hinstance = m;
		m_cur_pos = 0;
		m_element = m->getFirst();
	}
	T* Next()
	{
		return  &(m_element[m_cur_pos++]);
	}
	T* First()
	{
		m_element = m_hinstance->getFirst();
		m_cur_pos = 0;
		return m_element;
	}
	bool isDone()
	{
		//首先获得m_hinstance的总的数目和m_cur_pos比较
		if (m_cur_pos +1== m_hinstance->getNum())
		{
			return true;
		}
		return false;
	}
};

int main()
{
	TList<int> dsa;
	for (int i = 0; i < 20; i++)
	{
		dsa.Append(i);
	}
	//开始使用迭代器进行遍历
	Iterator_m<int>* mm = dsa.createIterator();
	//mm->First();
	while (!(mm->isDone()))
	{
		cout << *(mm->Next()) << endl;
	}
	return 0;
}

综上，其实迭代器就是一种封装的指针，其主要作用就是记录两个值，其一是容器实例的指针，其二记录当前迭代的位置，需要自定义实现isDone判断是否已经迭代到容器的末尾！！！！