stl::iterator汇总
一、概述
Iterator（迭代器）模式又称Cursor（游标）模式，
根据STL中的分类，iterator包括：
Input Iterator：只能单步向前迭代元素，不允许修改由该类迭代器引用的元素。(istream)
--------------------------------------
*iter 读取实际元素
iter 向前步进（传回新位置）
iter 向前步进 (传回旧位置)
== != 判断两个迭代器是否相等
TYPE(iter) 复制迭代器
--------------------------------------
Output Iterator：该类迭代器和Input Iterator极其相似，也只能单步向前迭代元素，不同的是该类迭代器对元素只有写的权力。(ostream, inserter)
--------------------------------------
*iter = value 将数值写到迭代器所指位置
--------------------------------------
Forward Iterator：是Input Iterator和Output Iterator的结合，具有Input的全部功能和Output的大部分功能。
--------------------------------------
iter1 = iter2 赋值
--------------------------------------
Bidirectional Iterator：该类迭代器是在Forward Iterator的基础上提供了单步向后迭代元素的能力。(list, set, multiset, map, multimap)
--------------------------------------
--iter
iter--
--------------------------------------
Random Access Iterator：该类迭代器能完成上面所有迭代器的工作，它自己独有的特性就是可以像指针那样进行算术计算，而不是仅仅只有单步向前或向后迭代。(vector, deque,string,array)
--------------------------------------
iter[n]
iter =n; iter-=n; iter n; n ter;
iter1-iter2; iter1<iter2...
--------------------------------------
二、结构
Iterator模式的结构如下图所示：
图1、stl的图未找到，此处为java中的迭代器模式图
四、优缺点
正如前面所说，与集合密切相关，限制了 Iterator模式的广泛使用，就个人而言，我不大认同将Iterator作为模式提出的观点，但它又确实符合模式“经常出现的特定问题的解决方案”的特质，以至于我又不得不承认它是个模式。在一般的底层集合支持类中，我们往往不愿“避轻就重”将集合设计成集合 Iterator 的形式，而是将遍历的功能直接交由集合完成，以免犯了“过度设计”的诟病，但是，如果我们的集合类确实需要支持多种遍历方式（仅此一点仍不一定需要考虑 Iterator模式，直接交由集合完成往往更方便），或者，为了与系统提供或使用的其它机制，如STL算法，保持一致时，Iterator模式才值得考虑。
五、举例
可以考虑使用两种方式来实现Iterator模式：内嵌类或者友元类。通常迭代类需访问集合类中的内部数据结构，为此，可在集合类中设置迭代类为friend class，但这不利于添加新的迭代类，因为需要修改集合类，添加friend class语句。也可以在抽象迭代类中定义protected型的存取集合类内部数据的函数，这样迭代子类就可以访问集合类数据了，这种方式比较容易添加新的迭代方式，但这种方式也存在明显的缺点：这些函数只能用于特定聚合类，并且，不可避免造成代码更加复杂。
以下是一个遍历二叉树的Iterator的例子，为了方便支持多种遍历方式，并便于遍历方式的扩展，其中还使用了Strategy模式（见笔记21）：
（注：1、虽然下面这个示例是本系列所有示例中花费我时间最多的一个，但我不得不承认，它非常不完善，感兴趣的朋友，可以考虑参考下面的参考材料将其补充完善，或提出宝贵改进意见。2、我本想考虑将其封装成与STL风格一致的形式，使得我们遍历二叉树必须通过Iterator来进行，但由于二叉树在结构上较线性存储结构复杂，使访问必须通过Iterator来进行，但这不可避免使得BinaryTree的访问变得异常麻烦，在具体应用中还需要认真考虑。3、以下只提供了Inorder<中序>遍历iterator的实现。）
#include <assert.h>
#include <iostream>
#include <xutility>
#include <iterator>
#include <algorithm>
using namespace std;
template <typename T>
class BinaryTree;
template <typename T>
class Iterator;
template <typename T>
class BinaryTreeNode
{
public:
typedef BinaryTreeNode<T> NODE;
typedef BinaryTreeNode<T>* NODE_PTR;
BinaryTreeNode(const T& element) : data(element), leftChild(NULL), rightChild(NULL),parent(NULL) { }
BinaryTreeNode(const T& element, NODE_PTR leftChild, NODE_PTR rightChild)
:data(element), leftChild(leftChild), rightChild(rightChild), parent(NULL)
{
if (leftChild)
leftChild->setParent(this);
if (rightChild)
rightChild->setParent(this);
}
T getData(void) const { return data; }
NODE_PTR getLeft(void) const { return leftChild; }
NODE_PTR getRight(void) const { return rightChild; }
NODE_PTR getParent(void) const { return parent; }
void SetData(const T& data) { this->data = item; }
void setLeft(NODE_PTR ptr) { leftChild = ptr; ptr->setParent(this); }
void setRight(NODE_PTR ptr) { rightChild = ptr; ptr->setParent(this); }
void setParent(NODE_PTR ptr) { parent = ptr; }
private:
T data;
NODE_PTR leftChild;
NODE_PTR rightChild;
NODE_PTR parent; // pointer to parent node, needed by iterator
friend class BinaryTree<T>;
};
stl::iterator初探
c++中用于数据管理的话,在不考虑高效率的前提下,容器是个不错的选择(要求高效率的话请用数组).用到了STL一般也要和iterator打交道,一开始时以为它也就是个指向容器元素的指针,实际上它是个对象,以下为测试实例:
typedef struct stNode{
int Id;
char data[10];
}Node;
typedef std::vector<Node> vnode; // Node链表
typedef std::vector<Node*> vpnode; // Node指针链表
vnode node;
vpnode pnode;
bool init_vector() // 初始化两个链表
{
for (int i = 0; i < 10; i++) // 初始化node链表
{
Node tmp_node;
memset(&tmp_node, 0, sizeof(Node));
tmp_node.Id = i+1;
sprintf_s(tmp_node.data,10,"Name%d",i+1);
node.push_back(tmp_node);
}
for (int j = 0; j < 10; j++) // 初始化pnode链表
{
Node *tmp_node1 = new Node;
tmp_node1->Id = j+11;
sprintf_s(tmp_node1->data,10,"pName%d",j+11);
pnode.push_back(tmp_node1);
}
return true;
}
Node* getNode(const int Id) // 根据Id返回对应的Node指针
{
if (Id < 0)return(NULL);
for (vnode::iterator it = node.begin(); it != node.end(); it++) // it是指向元素的指针(暂时称为指针)
{
if (Id == (*it).Id) // 看这用法,不就是指针的用法吗?
{
//return it; 错误
return &(*it); // 正确, 此处可以看出,it并不是真正的指针,它只是具有指针某些特性的一个对象
}
}
for (vpnode::iterator itp = pnode.begin(); itp != pnode.end(); itp++) // 此时itp是二级指针
{
if (Id == (*itp)->Id)
{
return (*itp);
}
}
return(NULL);
}
Node getNode2(const int Id) // 根据Id返回对应的Node实体
{
Node rtNode;
memset(&rtNode, 0x00, sizeof(Node));
if (Id < 0)
return(rtNode);
for (vnode::iterator it = node.begin(); it != node.end(); it++) // it是指向元素的指针
{
if (Id == (*it).Id)
{
rtNode = (*it); // 返回Node实体
goto exit;
}
}
for (vpnode::iterator itp = pnode.begin(); itp != pnode.end(); itp++) // 此时itp是二级指针
{
if (Id == (*itp)->Id)
{
rtNode = (*(*itp)); // 不算是指针的用法?
goto exit;
}
}
exit:
return(rtNode);
}
// 测试代码
int _tmain(int argc, _TCHAR* argv[])
{
int id[] = {5,7,9,11,19,21,23};
init_vector();
Node *vectorNode = new Node;
for (int i = 0; i < sizeof(id)/sizeof(int); i++)
{
vectorNode = getNode(id[i]);
if(vectorNode != NULL)
printf("Found %d\n",vectorNode->Id);
else
printf("Not Found %d\n",id[i]);
}
Node vecNode;
for (int i = 0; i < sizeof(id)/sizeof(int); i++)
{
vecNode = getNode2(id[i]);
if(vecNode.Id != 0)
printf("Found %d\n",vecNode.Id);
else
printf("Not Found %d\n",id[i]);
}
return 0;
}
