C++学习笔记（5）迭代器

迭代器：设计了一个统一的遍历容器的方式。
这种设计模式叫做迭代器模式。

容器中对数据结构进行了一个封装，要想遍历整个数据元素，
用普通指针是无法访问容器的数据结构。
所以需要设计一个面向对象的指针来访问。

可以让容器中提供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;
}