迭代器:设计了一个统一的遍历容器的方式。
这种设计模式叫做迭代器模式。
容器中对数据结构进行了一个封装,要想遍历整个数据元素,
用普通指针是无法访问容器的数据结构。
所以需要设计一个面向对象的指针来访问。
可以让容器中提供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;
}