迭代器：設計了一個統一的遍歷容器的方式。
這種設計模式叫做迭代器模式。

容器中對資料結構進行了一個封裝，要想遍歷整個資料元素，
用普通指標是無法訪問容器的資料結構。
所以需要設計一個面向物件的指標來訪問。

可以讓容器中提供begin（）和end（）這個介面，用面想物件的指標通過這兩個介面就可以遍歷這個容器。

begin（）//指向第一個有效元素的位置。
end（）//指向最後一個有效元素的後繼的位置。

在遍歷時只需要容器提供一個++操作，就不需要去關注容器底層元素的型別是什麼了。
針對vector容器實現一個迭代器。

# include<iostream>

template<typename Container>
class Iterator;//迭代器的宣告

//vector容器
template<typename T>
class Vector
{
public:
	typedef Iterator<Vector<T>> iterator;//對迭代器進行了型別重定義

	typedef T value_type;

	Vector()//vector建構函式
	{
		mdata = new T[2];
		cursize =0;
		totalsize =2;
	}

	~Vector()
	{
		delete[]mdata;
		mdata=NULL;
	}
	void push_back(T val)
	{
		if(IsFull())
		{
			resize();
		}
		mdata[cursize++]=val;
	}
	void pop_back()
	{
		if(idEmpty())
		{
			throe execption("vector is empty!");
		}
		cursize--;
	}
	iterator begin()//vector容器中提供begin介面
	{
		return iterator(this,0);//返回第一個有效元素的位置
	}
	iterator end()//vector容器中提供end介面
	{
		return iterator(this,cursize);//返回最後一個有效元素的位置的後繼
	}
	T& operator[](int index)
	{
		return mdata[index];
	}
	bool IsFull()
	{
		return cursize == totalsize;
	}
private:
	void resize()
	{
		T* pnewspace = new T[totalsize*2];
		memcpy(pnewspace,mdata,sizeof(T)*totalsize);
		delete[]mdata;
		mdata=pnewspace;
		totalsize*=2;
	}
	T* mdata;
	int cursize;
	int totalsize;
};

//迭代器
template<typename Container>
class Iterator
{
public:
	Iterator(Container* pvec,int pos):mpvec(pvec),mpos(pos)
	{}
	bool operator!=(const Iterator<Container>& rhs)
	{
		return mpos!=rhs.mpos;
	}
	const Iterator operator++(int)//後置++，只需要一個型別宣告
	{
		const Iterator tmp(*this);
		mpos++;//mpos++沒有對this造成影響
		return tmp;
	}
	typename Container::value_type operator*()
	{
		return (*mpvec)[mpos];//mpevc是指向容器的指標，（*mpvec）解引用==於容器
	}
private:
	Container* mpvec;//面向物件的指標
	int mpos;//下標位置，區別元素
};

int main()
{
	Vector<int> vec;//生成一個容器物件
	for(int i=0;i<10;i++)
	{
		vec.push_back(i+1);
	}

	 Vector<int>::iterator it = vec.begin();

	for(it;it!=vec.end();it++)
	{
		std::cout<<*it<<std::endl;
	}
	return 0;
}
 

//針對String實現一個迭代器

class Iterator;
class String
{
public:
	typedef Iterator iterator;//在string中對迭代器型別進行重定義
	String(char* pstr):mpstr(new char[strlen(pstr)+1]())//建構函式
	{
		strcpy(mpstr,pstr);
	}
	String(const String& rhs)//拷貝建構函式
	{
		mpstr = new char[strlen(rhs.mpstr)+1]();
		strcpy(mpstr,rhs.mpstr);
	}
	String& operator=(const String& rhs)
	{
		if(this != &rhs)
		{
			delete[] mpstr;
			mpstr = new char[strlen(rhs.mpstr)+1]();
			strcpy(mpstr,rhs.mpstr);
		}
		return *this;
	}
	~String()
	{
		delete[] mpstr;
		mpstr=NULL;
	}
	char& operator[](int index)
	{
		return mpstr[index];
	}
	iterator begin();
	iterator end();

private:
	char* mpstr;
};

class Iterator
{
public:
	Iterator(String* string,int p):pstring(string),pos(p){}//建構函式
	//針對建構函式沒有進行動態開闢（只需要賦值），不需要析構
	Iterator& operator++()
	{
		++pos;
		return *this;
	}
	char& operator*()
	{
		return(*pstring)[pos];
	}
	bool operator!=(const Iterator& rhs)
	{
		return pos!=rhs.pos;
	}
private:
	String* pstring;//Iterator生成的物件為面向物件的一個指標，內部成員變數的設計應該為容器的指標
	int pos;//下標：區別元素
};
String::iterator String::begin()
{
	return iterator(this,0);
}
String::iterator String::end()
{
	return iterator(this,strlen(mpstr));
}
int main()
{
	String str1("hello world!");
	String::iterator it=str1.begin();
	for(it;it!=str1.end();++it)
	{
		std::cout<<*it;
	}
	std::cout<<std::endl;
	return 0;
}