C++ STL 基础及应用(3) 迭代器

时间：2016-05-27 12:23:27 阅读：273 评论：0 收藏：0 [点我收藏+]

标签：

迭代器(Iterator)是 STL 的核心技术，提供了统一访问容器元素的方法，为编写通用算法提供了坚实的技术基础。

本章将带你编写一个自带迭代器的数组类和一个自带迭代器的链表类，模拟 STL 中的容器，这两个实例能够很清晰地展示 STL 的迭代器思想。并探讨迭代器类应该作为容器类的内部类的原因，然后对 STL 迭代器做一下归纳理解，最后阐述一下 STL 中真正的迭代器概况。

那么什么是迭代器呢？

迭代器即指针，可以是需要的任意类型，它的最大好处是可以使容器和算法分离。例如，有两个容器类，MyArray 是某类数组集合；MyLink 是某类型链表集合。它们都有显示、查询和排序等功能，常规思维是每个容器都有自己的显示、查询和排序等函数。但是细想，不同容器中完成相同功能代码的思路大致是相同的，那么能不能把它们抽象出来，多个容器仅对应一个显示、一个查询、一个排序函数呢？这是泛型思想发展的必然结果，于是迭代器思维就产生了。下面将通过实例来加深对迭代器的理解。

注意！对于下面代码中的模板使用、数组类编写有困惑的童鞋可以先看上一篇博文。

接下来编写带有迭代器的数组类链表类，模拟 STL 中的容器，展示 STL 的迭代器思维。

假设有一个动态数组类：

（比上一章节的数组类仅多了 Begin() 和 End() 方法）

//数组类
template <class T>
class MyArray
{
private:
    int m_nTotalSize;    //数组总长度
    int m_nValidSize;    //数组有效长度，即当前元素数
    T * m_pData;    //数据指针
public:
    //构造函数
    MyArray(int nSize=2)    //假设默认数组长度为2
    {
        m_pData=new T[nSize];
        m_nTotalSize=nSize;
        m_nValidSize=0;
    }
    //获取数组有效长度
    int GetValidSize()
    {
        return m_nValidSize;
    }
    //获取数组总长度
    int GetTotalSize()
    {
        return m_nTotalSize;
    }
    //返回某一位置元素
    T Get(int pos)
    {
        return m_pData[pos];
    }
    //添加一个元素
    void Add(T value)
    {
        if(m_nValidSize<m_nTotalSize)    //若数组未满
        {
            m_pData[m_nValidSize]=value;
            m_nValidSize++;
        }
        else    //数组满时动态增加数组大小
        {
            T * pOldData=m_pData;    //保存当前数据指针
            m_pData=new T[m_nTotalSize*2];    //原先数组空间大小扩大两倍
            for(int i=0;i<m_nTotalSize;i++)    //拷贝原先数据
            {
                m_pData[i]=pOldData[i];
            }
            m_nTotalSize*=2;    //当前数组总长度更新
            delete pOldData;    //释放旧数组占用的内存
            m_pData[m_nValidSize]=value;    //添加新元素
            m_nValidSize++;    //更新数组有效程度
        }
    }
    //返回头指针
    T * Begin()
    {
        return m_pData;
    }
    //返回尾指针
    T * End()
    {
        return m_pData+m_nValidSize;
    }
    virtual ~MyArray()
    {
    if(m_pData!=NULL)
      {
        delete []m_pData;
        m_pData=NULL;
       }
    }
};

然后有一个链表类：

//链表结点数据结构
template <class T>
struct Unit
{
    T value;
    Unit * next;
};

//链表类
template <class T>
class MyLink
{
private:
    Unit<T> * head;    //链表头
    Unit<T> * tail;    //链表尾
    Unit<T> * prev;    //指向最后一个结点
public:
    //构造函数
    MyLink()
    {
        head=tail=prev=NULL;
    }
    //添加一个结点
    void Add(const T &value)
    {
        Unit<T> *u=new Unit<T>();
        u->value=value;
        u->next=NULL;
        if(head==NULL)
        {
            head=u;
            prev=u;
        }
        else
        {
            prev->next=u;
            prev=u;
        }
        tail=u->next;
    }
    //返回头指针
    Unit<T>* Begin()
    {
        return head;
    }
    //返回尾指针
    Unit<T>* End()
    {
        return tail;
    }
    //析构函数
    virtual ~MyLink()
    {
        Unit<T> *prev=head;
        Unit<T> *next=NULL;
        while(prev!=tail)
        {
            next=prev->next;
            delete prev;
            prev=next;
        }
    }
};

可以看出，MyArray 是模板元素 T 的数组类，MyLink 是模板元素 T 的链表类，以 struct Unit 为一个链表单元。那么如何以 MyArray 和 MyLink 为基础，完成一个共同的显示函数呢？首先从需求出发，逆向考虑，

先写一个泛型显示函数，如下所示：

//泛型显示函数
template <class T>
void Display(T Start,T End)
{
    cout<<endl;
    for(T i=Start;i!=End;i++)
    {
        cout<<*i<<" ";
    }
    cout<<endl;
}

该函数的模板参数即为迭代器类型，该泛型函数能够输出从迭代器 Start 至 End 之间的所有元素，指针支持 ++ 和 * 操作。Display() 函数与具体的容器没有直接关联，但是间接关联是必需的，对于 MyArray 来说，该参数相当于数组类中的 T* 操作，对于 Mylink 来说，该参数相当于链表类当中的 Unit<T>* 操作，所以该参数就相当于容器中元素的指针。

于是写出 MyArray 的迭代器 ArrayIterator 类为：

template<class T>
class ArrayIterator
{
private:
    T * t;
public:
    //构造函数
    ArrayIterator(T * t)
    {
        this->t=t;
    }
    //重载!=
    bool operator != (const ArrayIterator &it)
    {
        return this->t!=it.t;
    }
    //重载++
    void operator ++ (int)
    {
        t++;
    }
    //重载取值符*
    T operator *()
    {
        return *t;
    }
};

可以看出，ArrayIterator 类是对 T* 的再封装，必须重载 operator !=、++、* 操作符，这是由于 Display 泛型显示函数需要用到这些操作符。

同样地，增加链表类迭代器 LinkIterator 类，重载 operator !=、++、* 操作符：

template <class T>
class LinkIterator
{
private:
    T *t;
public:
    //构造函数
    LinkIterator(T *t)
    {
        this->t=t;
    }
    //重载!=
    bool operator !=(const LinkIterator &it)
    {
        return this->t!=it.t;
    }
    //重载++
    void operator ++(int)
    {
        t=t->next;
    }
    //重载取值符*
    T operator *()
    {
        return *t;
    }
};

可以看出 operator !=、operator * 的重载内容与 ArrayIterator 一致，只有 operator ++ 不同，因为这里链表并不像数组一样连续存储，它是指针的转向，所有不能是 t++ ，而应该是 t=t->next。

细心的同学会发现，若有一个链表类 MyLink，当使用链表类迭代器 LinkIterator Start 为参数使用 Display() 函数时，假设有一步要执行 cout<<*Start 时，根据 LinkIterator 对 operator * 的重载，该式等于 cout<<Unit<T> ,但是 Unit<T> 是一个复合类型，cout 显然不能输出，cout 只能输出 Unit<T>.value，因此需要重载全局函数 operator << ,代码如下：

//重载全局函数operator <<
template <class T>
ostream& operator<<(ostream& os,const Unit<T> &u)
{
    os<<u.value;
    return os;
}

最后给出测试函数如下：

int main()
{
    MyArray<float> ary;
    MyLink<int> link;

    ary.Add(1.1);
    ary.Add(2.2);
    ary.Add(3.3);
    link.Add(1);
    link.Add(2);
    link.Add(3);

    ArrayIterator<float> aryStart(ary.Begin());
    ArrayIterator<float> aryEnd(ary.End());

    //注意！！这里两个尖括号要分开
    LinkIterator<Unit<int> > linkStart(link.Begin());
    LinkIterator<Unit<int> > linkEnd(link.End());

    Display(aryStart,aryEnd);
    Display(linkStart,linkEnd);
    return 0;
}

过程可以描述为：定义一个容器对象，向其中添加数据，获得迭代器对象 Start 、End，最后调用泛型显式函数 Display 完成数据的输出。

这里给出上述完整的代码：

#include <iostream>
using namespace std;

//数组类
template <class T>
class MyArray
{
private:
    int m_nTotalSize;    //数组总长度
    int m_nValidSize;    //数组有效长度，即当前元素数
    T * m_pData;    //数据指针
public:
    //构造函数
    MyArray(int nSize=2)    //假设默认数组长度为2
    {
        m_pData=new T[nSize];
        m_nTotalSize=nSize;
        m_nValidSize=0;
    }
    //获取数组有效长度
    int GetValidSize()
    {
        return m_nValidSize;
    }
    //获取数组总长度
    int GetTotalSize()
    {
        return m_nTotalSize;
    }
    //返回某一位置元素
    T Get(int pos)
    {
        return m_pData[pos];
    }
    //添加一个元素
    void Add(T value)
    {
        if(m_nValidSize<m_nTotalSize)    //若数组未满
        {
            m_pData[m_nValidSize]=value;
            m_nValidSize++;
        }
        else    //数组满时动态增加数组大小
        {
            T * pOldData=m_pData;    //保存当前数据指针
            m_pData=new T[m_nTotalSize*2];    //原先数组空间大小扩大两倍
            for(int i=0;i<m_nTotalSize;i++)    //拷贝原先数据
            {
                m_pData[i]=pOldData[i];
            }
            m_nTotalSize*=2;    //当前数组总长度更新
            delete pOldData;    //释放旧数组占用的内存
            m_pData[m_nValidSize]=value;    //添加新元素
            m_nValidSize++;    //更新数组有效程度
        }
    }
    //返回头指针
    T * Begin()
    {
        return m_pData;
    }
    //返回尾指针
    T * End()
    {
        return m_pData+m_nValidSize;
    }
    virtual ~MyArray()
    {
    if(m_pData!=NULL)
      {
        delete []m_pData;
        m_pData=NULL;
       }
    }
};

//链表结点数据结构
template <class T>
struct Unit
{
    T value;
    Unit * next;
};

//链表类
template <class T>
class MyLink
{
private:
    Unit<T> * head;    //链表头
    Unit<T> * tail;    //链表尾
    Unit<T> * prev;    //指向最后一个结点
public:
    //构造函数
    MyLink()
    {
        head=tail=prev=NULL;
    }
    //添加一个结点
    void Add(const T &value)
    {
        Unit<T> *u=new Unit<T>();
        u->value=value;
        u->next=NULL;
        if(head==NULL)
        {
            head=u;
            prev=u;
        }
        else
        {
            prev->next=u;
            prev=u;
        }
        tail=u->next;
    }
    //返回头指针
    Unit<T>* Begin()
    {
        return head;
    }
    //返回尾指针
    Unit<T>* End()
    {
        return tail;
    }
    //析构函数
    virtual ~MyLink()
    {
        Unit<T> *prev=head;
        Unit<T> *next=NULL;
        while(prev!=tail)
        {
            next=prev->next;
            delete prev;
            prev=next;
        }
    }
};

//泛型显示函数
template <class T>
void Display(T Start,T End)
{
    cout<<endl;
    for(T i=Start;i!=End;i++)
    {
        cout<<*i<<" ";
    }
    cout<<endl;
}

template<class T>
class ArrayIterator
{
private:
    T * t;
public:
    //构造函数
    ArrayIterator(T * t)
    {
        this->t=t;
    }
    //重载!=
    bool operator != (const ArrayIterator &it)
    {
        return this->t!=it.t;
    }
    //重载++
    void operator ++ (int)
    {
        t++;
    }
    //重载取值符*
    T operator *()
    {
        return *t;
    }
};

template <class T>
class LinkIterator
{
private:
    T *t;
public:
    //构造函数
    LinkIterator(T *t)
    {
        this->t=t;
    }
    //重载!=
    bool operator !=(const LinkIterator &it)
    {
        return this->t!=it.t;
    }
    //重载++
    void operator ++(int)
    {
        t=t->next;
    }
    //重载取值符*
    T operator *()
    {
        return *t;
    }
};

//重载全局函数operator <<
template <class T>
ostream& operator<<(ostream& os,const Unit<T> &u)
{
    os<<u.value;
    return os;
}

int main()
{
    MyArray<float> ary;
    MyLink<int> link;

    ary.Add(1.1);
    ary.Add(2.2);
    ary.Add(3.3);
    link.Add(1);
    link.Add(2);
    link.Add(3);

    ArrayIterator<float> aryStart(ary.Begin());
    ArrayIterator<float> aryEnd(ary.End());

    //注意！！这里两个尖括号要分开
    LinkIterator<Unit<int> > linkStart(link.Begin());
    LinkIterator<Unit<int> > linkEnd(link.End());

    Display(aryStart,aryEnd);
    Display(linkStart,linkEnd);
    return 0;
}

关于迭代器类位置的探讨

每一种容器对应一种迭代器，如数组迭代器只适用于数组，那么基于封装的思想，迭代器类自然就必须位于它所对应容器类的内部，即成为容器类的内部类。

将数组迭代器 ArrayIterator 放入数组类 MyArray 中：

//数组类
template <class T>
class MyArray
{
private:
    int m_nTotalSize;    //数组总长度
    int m_nValidSize;    //数组有效长度，即当前元素数
    T * m_pData;    //数据指针
public:
    //构造函数
    MyArray(int nSize=2)    //假设默认数组长度为2
    {
        m_pData=new T[nSize];
        m_nTotalSize=nSize;
        m_nValidSize=0;
    }
    //数组迭代器
    class ArrayIterator
    {
	private:
		T * t;
	public:
		//构造函数
		ArrayIterator(T * t)
		{
			this->t=t;
		}
		//重载!=
		bool operator != (const ArrayIterator &it)
		{
			return this->t!=it.t;
		}
		//重载++
		void operator ++ (int)
		{
			t++;
		}
		//重载取值符*
		T operator *()
		{
			return *t;
		}
    };
    //获取数组有效长度
    int GetValidSize()
    {
        return m_nValidSize;
    }
    //获取数组总长度
    int GetTotalSize()
    {
        return m_nTotalSize;
    }
    //返回某一位置元素
    T Get(int pos)
    {
        return m_pData[pos];
    }
    //添加一个元素
    void Add(T value)
    {
        if(m_nValidSize<m_nTotalSize)    //若数组未满
        {
            m_pData[m_nValidSize]=value;
            m_nValidSize++;
        }
        else    //数组满时动态增加数组大小
        {
            T * pOldData=m_pData;    //保存当前数据指针
            m_pData=new T[m_nTotalSize*2];    //原先数组空间大小扩大两倍
            for(int i=0;i<m_nTotalSize;i++)    //拷贝原先数据
            {
                m_pData[i]=pOldData[i];
            }
            m_nTotalSize*=2;    //当前数组总长度更新
            delete pOldData;    //释放旧数组占用的内存
            m_pData[m_nValidSize]=value;    //添加新元素
            m_nValidSize++;    //更新数组有效程度
        }
    }
    //返回头指针
    T * Begin()
    {
        return m_pData;
    }
    //返回尾指针
    T * End()
    {
        return m_pData+m_nValidSize;
    }
    //析构函数
    virtual ~MyArray()
    {
    if(m_pData!=NULL)
      {
        delete []m_pData;
        m_pData=NULL;
       }
    }
};

注意！与原代码相比少了很多尖括号，并且由于模板编程的规则有好几处稍许变化的地方，希望读者能留心发现。

然后将链表迭代器 LinkIterator 放入链表类 MyLink 中：

//链表类
template <class T>
class MyLink
{
public:
    //链表结点数据结构
    struct Unit
    {
        T value;
        Unit * next;
    };
	//链表类迭代器
    class LinkIterator
    {
        private:
            Unit *u;
        public:
            //构造函数
            LinkIterator(Unit *u)
            {
                this->u=u;
            }
            //重载!=
            bool operator !=(const LinkIterator &it)
            {
                return this->u!=it.u;
            }
            //重载++
            void operator ++(int)
            {
                u=u->next;
            }
            //重载取值符*
            Unit operator *()
            {
                return *this->u;
            }
    };
    //重载全局函数operator <<
    friend ostream& operator<<(ostream& os,typename MyLink<T>::Unit& u)
    {
        os<<u.value;
        return os;
    }
    //构造函数
    MyLink()
    {
        head=tail=prev=NULL;
    }
    //添加一个结点
    void Add(const T &value)
    {
        Unit *u=new Unit();
        u->value=value;
        u->next=NULL;
        if(head==NULL)
        {
            head=u;
            prev=u;
        }
        else
        {
            prev->next=u;
            prev=u;
        }
        tail=u->next;
    }
    //返回头指针
    Unit * Begin()
    {
        return head;
    }
    //返回尾指针
    Unit * End()
    {
        return tail;
    }
    //析构函数
    virtual ~MyLink()
    {
        if(head!=NULL)
        {
            Unit *prev=head;
            Unit *next=NULL;
            while(prev!=tail)
            {
                next=prev->next;
                delete prev;
                prev=next;
            }
        }
    }
private:
    Unit * head;    //链表头
    Unit * tail;    //链表尾
    Unit * prev;    //指向最后一个结点
};

由于该 struct Unit 结构体为该链表类专用，因此也一并放进了 MyArray 类中。值得注意的是，全局函数 cout<< 的重载也被放了进来，因为只有用到这个链表类时，才会有 cout<<Unit<T> 的必要，因此要一并封装。另外，为了能使 ostream 对象访问该类的私有变量，必须将这个重载函数用 friend 关键字写为友元函数。

Display()函数不用变化，测试函数相应地修改为：

int main()
{
    MyArray<float> ary;
    MyLink<int> link;

    ary.Add(1.1f);
    ary.Add(2.2f);
    ary.Add(3.3f);

    link.Add(1);
    link.Add(2);
    link.Add(3);

    MyArray<float>::ArrayIterator aryStart(ary.Begin());
    MyArray<float>::ArrayIterator aryEnd(ary.End());

    MyLink<int>::LinkIterator linkStart(link.Begin());
    MyLink<int>::LinkIterator linkEnd(link.End());

    Display(aryStart,aryEnd);
    Display(linkStart,linkEnd);

    return 0;
}

最后给上封装之后的完成代码，一共只有两个类 MyArray 与 MyLink，迭代器被封装在了类中，然后有一个公共的显示函数 Display() 和一个测试函数 main()，代码如下：

#include <iostream>
using namespace std;

//数组类
template <class T>
class MyArray
{
private:
    int m_nTotalSize;    //数组总长度
    int m_nValidSize;    //数组有效长度，即当前元素数
    T * m_pData;    //数据指针
public:
    //构造函数
    MyArray(int nSize=2)    //假设默认数组长度为2
    {
        m_pData=new T[nSize];
        m_nTotalSize=nSize;
        m_nValidSize=0;
    }
    //数组迭代器
    class ArrayIterator
    {
	private:
		T * t;
	public:
		//构造函数
		ArrayIterator(T * t)
		{
			this->t=t;
		}
		//重载!=
		bool operator != (const ArrayIterator &it)
		{
			return this->t!=it.t;
		}
		//重载++
		void operator ++ (int)
		{
			t++;
		}
		//重载取值符*
		T operator *()
		{
			return *t;
		}
    };
    //获取数组有效长度
    int GetValidSize()
    {
        return m_nValidSize;
    }
    //获取数组总长度
    int GetTotalSize()
    {
        return m_nTotalSize;
    }
    //返回某一位置元素
    T Get(int pos)
    {
        return m_pData[pos];
    }
    //添加一个元素
    void Add(T value)
    {
        if(m_nValidSize<m_nTotalSize)    //若数组未满
        {
            m_pData[m_nValidSize]=value;
            m_nValidSize++;
        }
        else    //数组满时动态增加数组大小
        {
            T * pOldData=m_pData;    //保存当前数据指针
            m_pData=new T[m_nTotalSize*2];    //原先数组空间大小扩大两倍
            for(int i=0;i<m_nTotalSize;i++)    //拷贝原先数据
            {
                m_pData[i]=pOldData[i];
            }
            m_nTotalSize*=2;    //当前数组总长度更新
            delete pOldData;    //释放旧数组占用的内存
            m_pData[m_nValidSize]=value;    //添加新元素
            m_nValidSize++;    //更新数组有效程度
        }
    }
    //返回头指针
    T * Begin()
    {
        return m_pData;
    }
    //返回尾指针
    T * End()
    {
        return m_pData+m_nValidSize;
    }
    //析构函数
    virtual ~MyArray()
    {
    if(m_pData!=NULL)
      {
        delete []m_pData;
        m_pData=NULL;
       }
    }
};

//链表类
template <class T>
class MyLink
{
public:
    //链表结点数据结构
    struct Unit
    {
        T value;
        Unit * next;
    };
	//链表类迭代器
    class LinkIterator
    {
        private:
            Unit *u;
        public:
            //构造函数
            LinkIterator(Unit *u)
            {
                this->u=u;
            }
            //重载!=
            bool operator !=(const LinkIterator &it)
            {
                return this->u!=it.u;
            }
            //重载++
            void operator ++(int)
            {
                u=u->next;
            }
            //重载取值符*
            Unit operator *()
            {
                return *this->u;
            }
    };
    //重载全局函数operator <<
    friend ostream& operator<<(ostream& os,typename MyLink<T>::Unit& u)
    {
        os<<u.value;
        return os;
    }
    //构造函数
    MyLink()
    {
        head=tail=prev=NULL;
    }
    //添加一个结点
    void Add(const T &value)
    {
        Unit *u=new Unit();
        u->value=value;
        u->next=NULL;
        if(head==NULL)
        {
            head=u;
            prev=u;
        }
        else
        {
            prev->next=u;
            prev=u;
        }
        tail=u->next;
    }
    //返回头指针
    Unit * Begin()
    {
        return head;
    }
    //返回尾指针
    Unit * End()
    {
        return tail;
    }
    //析构函数
    virtual ~MyLink()
    {
        if(head!=NULL)
        {
            Unit *prev=head;
            Unit *next=NULL;
            while(prev!=tail)
            {
                next=prev->next;
                delete prev;
                prev=next;
            }
        }
    }
private:
    Unit * head;    //链表头
    Unit * tail;    //链表尾
    Unit * prev;    //指向最后一个结点
};

//泛型显示函数
template <class T>
void Display(T Start,T End)
{
    cout<<endl;
    for(T i=Start;i!=End;i++)
    {
        cout<<*i;
        cout<<" ";
    }
    cout<<endl;
}

int main()
{
    MyArray<float> ary;
    MyLink<int> link;

    ary.Add(1.1f);
    ary.Add(2.2f);
    ary.Add(3.3f);

    link.Add(1);
    link.Add(2);
    link.Add(3);

    MyArray<float>::ArrayIterator aryStart(ary.Begin());
    MyArray<float>::ArrayIterator aryEnd(ary.End());

    MyLink<int>::LinkIterator linkStart(link.Begin());
    MyLink<int>::LinkIterator linkEnd(link.End());

    Display(aryStart,aryEnd);
    Display(linkStart,linkEnd);

    return 0;
}

注意！上述代码我在 VS 2010 下编译正确，运行正确，但在 CodeBlocks 用 GNU GCC 编译器编译时报错，难道是 GCC 编译器的bug？希望有知道的大神赐教。

恭喜！你已经能够编写一个带有迭代器的简易容器了，STL 中的容器也是以此为雏形完善代码而来的，现在你应该对于 STL 的迭代器概念有一个整体的认识了，接下来总结一下关于迭代器的思想。

进一步理解迭代器

前面已经详细讨论了迭代器的编程思路，如果用图形来描述一下就是：

图一：容器、迭代器、算法示意图

每一个容器都有对应的迭代器，容器通过迭代器来共享某一具体算法，某一具体算法不依附于某一个具体的容器。这里迭代器起到一个中间媒介的作用，通过它把容器与算法联系起来。换一句话说就是，迭代器是编写通用泛型算法发展的必然结果，算法通过迭代器依次访问容器中的元素。由上图也可以得出 STL 标准模板库编程的基本步骤。

STL 标准模板库编程的基本步骤：

1.形成容器元素
2.获得需要的迭代指针
3.调用通用算法

其实，生活中有很多“迭代器”的现象，如千家万户通过电话线来上网获取资源，这里电话线就类似于一个迭代器，每一个家庭就相当于容器的一个结点。

STL 迭代器
现在来看看 STL 中真正的迭代器是怎么样的。

按照功能划分，迭代器共分为5大类：

(1)输入迭代器(Input Iterator)
(2)输出迭代器(Output Iterator)
(3)前向迭代器(Forword Iterator)
(4)双向迭代器(Bidirectional Iterator)
(5)随机访问迭代器(Random Access Iterator)

(1)输入迭代器(Input Iterator)

按顺序只读一次。完成的功能有：能进行构造和默认构造，能够被复制和被赋值，能进行相等性比较，能进行逐步向前移动，能进行读取值。输入迭代器重载的主要操作符如下所示：
operator * 访问迭代元素值
operator == 迭代元素相等比较
operator ++() 前置迭代指针++
operator != 迭代元素不等比较
operator ++(int) 后置迭代指针++

STL 提供的主要输入迭代器是 istream_iterator，支持上表中的所有操作。值得注意的是它的构造函数，有两种形式：
istream_iterator(): 默认的构造函数，创建了一个流结束的迭代器。
istream_iterator(istream &): 参数是输入流。含义是从输入流中读取数据，当遇到流结束符时停止。

一个使用 istream_iterator 迭代器迭代标准输入流的实例如下所示：

#include <iostream>
#include <iterator>
using namespace std;

int main()
{
	cout<<"请输入数据(如1 2 3,):";
	istream_iterator<int> Start(cin);    //建立键盘输入流
	istream_iterator<int> End;    //建立输入流结束迭代器
	while(1)
	{
		cout<<*Start<<endl;
		Start++;
		if(Start==End)
			break;
	}
	return 0;
}

程序执行结果为：
请输入数据(如1 2 3,):1 2 3,
1
2
3

程序分析如下所示：
①先从键盘(标准输入)输入相应数据，按 Enter 键后，调用 istream_iterator 迭代器进行枚举数据，迭代器指针指向第一个符合要求的数据。
②利用循环输出枚举数据，若迭代器指针已到达数据流尾部，则退出循环。那么如何判断到达数据流尾部呢？从程序中可以看出如果迭代指针 Start 不停累加到等于 End 时即可。而 End 是调用无参数的 istream_iterator 构造函数获得的，指向输入流结束位置。

注意！本例中输入的是"1 2 3,"，后面跟一个逗号，若无逗号则 istream_iterator<int> Start(cin) 则不会执行完，这是由于迭代类型时整型数，只有在流中输入非整型数，迭代器迭代到此位置时发现它不是整型数才停止工作。当然，这里最后的"，"可以用其他任意非整型数来替换。

(2)输出迭代器(Output Iterator)

只写一次。完成的功能有：能进行构造或默认构造，能被复制或赋值，能进行相等性比较，能进行逐步向前移动，能进行写入值(*p=x)，但不能读出。输出迭代器重载的主要操作符如下所示：
operator * 分配迭代元素值空间
operator ++() 前置迭代指针++
operator = 写入元素值
operator ++(int) 后置迭代指针++

STL 提供的主要输出迭代器是 ostream_iterator,支持上表中的所有操作。它的构造函数也有两种形式：
ostream_iterator(ostream& Out): 创建了流输出迭代器，用来迭代 out 输出流。
ostream_iterator(ostream& Out,const char *delim): 创建了流输出迭代器，用来向 Out 输出流输出数据，输出的数据之间用 delim 字符串分隔。即每向 Out 输出流输出一个数据后，就向 Out 输出流输出一个分隔符 delim 。

一个使用 ostream_iterator 迭代器迭代标准输出流的实例如下所示：

#include <iostream>
#include <iterator>
using namespace std;

int main()
{
	ostream_iterator<int> Out(cout,"\t");
	*Out=1;
	Out++;
	*Out=2;
	Out++;
	*Out=3;
	Out++;
	return 0;
}

程序执行结果为：
1 2 3

(3)前向迭代器(Forword Iterator)

使用输入迭代器和输入迭代器基本可以满足算法和容器的要求，但是还有一些算法需要同时具备两者的功能，例如 Replace 算法就是一例。前向迭代器就是为满足这些需求而定义的。先看看 Replace 算法(用新值代替旧值)的需求。

template <class ForwardIterator,class T>
void Replace(ForwardIterator first,ForwardIterator last,const T& old_value,const T& new_value)
{
	for(;first!=last;first++)
		if(*first==old_value)
			*first=new_value;
}

这里的 first，就是 ForwardIterator 的模型，其需求包括 first!=last、first++、*first==old_value、*first=new_value。这样，Forward Iterator 的需求概括为：能进行构造或默认构造，能被复制或赋值，能进行相等性比较，能进行逐步前向移动，能进行读取值(但不能进行改写)。前向迭代器包含了输入和输出迭代器两者的所有功能，加上还可以多次解析一个迭代器指定的位置，因此可以对一个值多次进行读写。顾名思义，前向迭代器只能向前移动。但是 STL 本事并没有专门为前向迭代器预定义的迭代器。

(4)双向迭代器(Bidirectional Iterator)

具有前向迭代器的全部功能，另外它还可以利用自减操作符 operator -- 向后一次移动一个位置，例如双向链表容器中需要的就是双向迭代器。

(5)随机访问迭代器(Random Access Iterator)

具有双向访问迭代器的所有功能，再加上一个指针所有的功能，包括使用操作符 operator [] 进行索引，加某个整数值到一个指针就可以向前或向后移动若干个位置，或者使用比较运算符在迭代器之间进行比较。

综观5种迭代器，发现从前到后的需求越来越多，这就是所谓的细化。因为如此，在一切情况下都可以使用需求最细的 Random Access Iterator，确实可以，但是不好，因为过多的需求自然会降低它的效率，实际编程时应该选择正好适合的 Iterator 来得到最高的效率。

C++ STL 基础及应用(3) 迭代器

标签：

原文地址：http://blog.csdn.net/raito__/article/details/51494599

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行