精华内容
下载资源
问答
  • C++迭代器 iterator

    2015-10-24 19:31:30
    C++迭代器 iterator 1. 迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。 (1) 每种容器类型都定义了自己的迭代器类型,如vector: vector::iterator iter;这条语句定义了一个名为iter的变量,它...
    
    

    1. 迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。
    (1) 每种容器类型都定义了自己的迭代器类型,如vector:
    vector<int>::iterator iter;这条语句定义了一个名为iter的变量,它的数据类型是由vector<int>定义的iterator类型。
    (2) 使用迭代器读取vector中的每一个元素:
    vector<int> ivec(10,1);
    for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    {
    *iter=2; //使用 * 访问迭代器所指向的元素
    }
    const_iterator:
    只能读取容器中的元素,而不能修改。
    for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
    {
    cout<<*citer;
    //*citer=3; error
    }
    vector<int>::const_iterator 和 const vector<int>::iterator的区别
    const vector<int>::iterator newiter=ivec.begin();
    *newiter=11; //可以修改指向容器的元素
    //newiter++; //迭代器本身不能被修改 
    (3) iterator的算术操作:
    iterator除了进行++,--操作,可以将iter+n,iter-n赋给一个新的iteraor对象。还可以使用一个iterator减去另外一个iterator.
    const vector<int>::iterator newiter=ivec.begin();
    vector<int>::iterator newiter2=ivec.end();
    cout<<"\n"<<newiter2-newiter; 
    一個很典型使用vector的STL程式:
    1 #include <vector>
    2 #include <iostream>

    4 using namespace std;

    6 int main() {
    7 vector<int> ivec;
    8 ivec.push_back(1);
    9 ivec.push_back(2);
    10 ivec.push_back(3);
    11 ivec.push_back(4);
    12 
    13 for(vector<int>::iterator iter = ivec.begin();1. iter != ivec.end(); ++iter)
    14 cout << *iter << endl;
    15 }
    2. Iterator(迭代器)模式
    一、概述
        Iterator(迭代器)模式又称Cursor(游标)模式,用于提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。或者这样说可能更容易理解:Iterator模式是运用于聚合对象的一种模式,通过运用该模式,使得我们可以在不知道对象内部表示的情况下,按照一定顺序(由iterator提供的方法)访问聚合对象中的各个元素。
        由于Iterator模式的以上特性:与聚合对象耦合,在一定程度上限制了它的广泛运用,一般仅用于底层聚合支持类,如STL的list、vector、stack等容器类及ostream_iterator等扩展iterator。
        根据STL中的分类,iterator包括:
    Input Iterator:只能单步向前迭代元素,不允许修改由该类迭代器引用的元素。
    Output Iterator:该类迭代器和Input Iterator极其相似,也只能单步向前迭代元素,不同的是该类迭代器对元素只有写的权力。
    Forward Iterator:该类迭代器可以在一个正确的区间中进行读写操作,它拥有Input Iterator的所有特性,和Output Iterator的部分特性,以及单步向前迭代元素的能力。
    Bidirectional Iterator:该类迭代器是在Forward Iterator的基础上提供了单步向后迭代元素的能力。
    Random Access Iterator:该类迭代器能完成上面所有迭代器的工作,它自己独有的特性就是可以像指针那样进行算术计算,而不是仅仅只有单步向前或向后迭代。
        这五类迭代器的从属关系,如下图所示,其中箭头A→B表示,A是B的强化类型,这也说明了如果一个算法要求B,那么A也可以应用于其中。

    input output
          \ /
    forward
           |
    bidirectional
           |
    random access
     图1、五种迭代器之间的关系
        vector 和deque提供的是RandomAccessIterator,list提供的是BidirectionalIterator,set和map提供的 iterators是 ForwardIterator,关于STL中iterator迭代器的操作如下:
    说明:每种迭代器均可进行包括表中前一种迭代器可进行的操作。
    迭代器操作                      说明
    (1)所有迭代器
    p++                              后置自增迭代器
    ++p                              前置自增迭代器
    (2)输入迭代器
    *p                                 复引用迭代器,作为右值
    p=p1                             将一个迭代器赋给另一个迭代器
    p==p1                           比较迭代器的相等性
    p!=p1                            比较迭代器的不等性
    (3)输出迭代器
    *p                                 复引用迭代器,作为左值
    p=p1                             将一个迭代器赋给另一个迭代器
    (4)正向迭代器
    提供输入输出迭代器的所有功能
    (5)双向迭代器
    --p                                前置自减迭代器
    p--                                后置自减迭代器
    (6)随机迭代器
    p+=i                              将迭代器递增i位
    p-=i                               将迭代器递减i位
    p+i                                在p位加i位后的迭代器
    p-i                                 在p位减i位后的迭代器
    p[i]                                返回p位元素偏离i位的元素引用
    p<p1                             如果迭代器p的位置在p1前,返回true,否则返回false
    p<=p1                           p的位置在p1的前面或同一位置时返回true,否则返回false
    p>p1                             如果迭代器p的位置在p1后,返回true,否则返回false
    p>=p1                           p的位置在p1的后面或同一位置时返回true,否则返回false
        只有顺序容器和关联容器支持迭代器遍历,各容器支持的迭代器的类别如下:
    容器                 支持的迭代器类别            容器               支持的迭代器类别            容器                 支持的迭代器类别
    vector              随机访问                      deque              随机访问                       list                   双向
    set                   双向                            multiset            双向                           map                 双向
    multimap          双向                             stack                不支持                        queue              不支持
    priority_queue   不支持
    二、结构
    Iterator模式的结构如下图所示:


    图2、Iterator模式类图示意
    三、应用
        Iterator模式有三个重要的作用:
    1)它支持以不同的方式遍历一个聚合.复杂的聚合可用多种方式进行遍历,如二叉树的遍历,可以采用前序、中序或后序遍历。迭代器模式使得改变遍历算法变得很容易: 仅需用一个不同的迭代器的实例代替原先的实例即可,你也可以自己定义迭代器的子类以支持新的遍历,或者可以在遍历中增加一些逻辑,如有条件的遍历等。
    2)迭代器简化了聚合的接口. 有了迭代器的遍历接口,聚合本身就不再需要类似的遍历接口了,这样就简化了聚合的接口。
    3)在同一个聚合上可以有多个遍历 每个迭代器保持它自己的遍历状态,因此你可以同时进行多个遍历。
    4)此外,Iterator模式可以为遍历不同的聚合结构(需拥有相同的基类)提供一个统一的接口,即支持多态迭代。
        简单说来,迭代器模式也是Delegate原则的一个应用,它将对集合进行遍历的功能封装成独立的Iterator,不但简化了集合的接口,也使得修改、增 加遍历方式变得简单。从这一点讲,该模式与Bridge模式、Strategy模式有一定的相似性,但Iterator模式所讨论的问题与集合密切相关, 造成在Iterator在实现上具有一定的特殊性,具体将在示例部分进行讨论。
    四、优缺点
         正如前面所说,与集合密切相关,限制了 Iterator模式的广泛使用,就个人而言,我不大认同将Iterator作为模式提出的观点,但它又确实符合模式“经常出现的特定问题的解决方案”的 特质,以至于我又不得不承认它是个模式。在一般的底层集合支持类中,我们往往不愿“避轻就重”将集合设计成集合 + Iterator 的形式,而是将遍历的功能直接交由集合完成,以免犯了“过度设计”的诟病,但是,如果我们的集合类确实需要支持多种遍历方式(仅此一点仍不一定需要考虑 Iterator模式,直接交由集合完成往往更方便),或者,为了与系统提供或使用的其它机制,如STL算法,保持一致时,Iterator模式才值得考 虑。
    五、举例
        可以考虑使用两种方式来实现Iterator模式:内嵌类或者友元类。通常迭代类需访问集合类中的内部数据结构,为此,可在集合类中设置迭代类为friend class,但这不利于添加新的迭代类,因为需要修改集合类,添加friend class语句。也可以在抽象迭代类中定义protected型的存取集合类内部数据的函数,这样迭代子类就可以访问集合类数据了,这种方式比较容易添加新的迭代方式,但这种方式也存在明显的缺点:这些函数只能用于特定聚合类,并且,不可避免造成代码更加复杂。
        STL的list::iterator、deque::iterator、rbtree::iterator等采用的都是外部Iterator类的形式,虽然STL的集合类的iterator分散在各个集合类中,但由于各Iterator类具有相同的基类,保持了相同的对外的接口(包括一些traits及tags等,感兴趣者请认真阅读参考1、2),从而使得它们看起来仍然像一个整体,同时也使得应用algorithm成为可能。我们如果要扩展STL的iterator,也需要注意这一点,否则,我们扩展的iterator将可能无法应用于各algorithm。
    以下是一个遍历二叉树的Iterator的例子,为了方便支持多种遍历方式,并便于遍历方式的扩展,其中还使用了Strategy模式(见笔记21):
    (注:1、虽然下面这个示例是本系列所有示例中花费我时间最多的一个,但我不得不承认,它非常不完善,感兴趣的朋友,可以考虑参考下面的参考材料将其补充完善,或提出宝贵改进意见。2、 我本想考虑将其封装成与STL风格一致的形式,使得我们遍历二叉树必须通过Iterator来进行,但由于二叉树在结构上较线性存储结构复杂,使访问必须 通过Iterator来进行,但这不可避免使得BinaryTree的访问变得异常麻烦,在具体应用中还需要认真考虑。3、以下只提供了Inorder<中序>遍历iterator的实现。)

    展开全文
  • C++迭代器iterator

    2019-04-24 21:46:20
    迭代器iteratorC++STL的组件之一,作用是用来遍历容器,而且是通用的遍历容器的方式。 说到C++STL组件就不得不提一下C++STL的六大组件了,它们分别是:顺序/无序容器、关联容器、容器适配器、迭代器、函数对象、...

    1、迭代器的概念

    迭代器iterator是C++STL的组件之一,作用是用来遍历容器,而且是通用的遍历容器的方式。
    说到C++STL组件就不得不提一下C++STL的六大组件了,它们分别是:顺序/无序容器、关联容器、容器适配器、迭代器、函数对象、泛型算法。
    

    经典的迭代器遍历容器的代码如下:

    Vector<int>::iterator it = vec1 .begin();
    	for (; it != vec1 .end(); ++it)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    

    实际上C++1新标准的foreach语句,对于容器的遍历就是迭代器实现的,上面的语句可以简化为:

    for(int val:vec)
    	{
    		cout << val << "";
    	}
    	cout << endl;
    

    下面是迭代器的简单实现以及一些方法:

    class iterator
    	{
    	public:
    		// 定义友元类 
    		friend class Vector<T>;
    
    		iterator(T *p = nullptr) 
    			:_ptr(p) {}
    		bool operator!=(const iterator &it)const
    		{
    			return _ptr != it._ptr;
    		}
    		bool operator==(const iterator &it)const
    		{
    			return _ptr == it._ptr;
    		}
    		int operator-(const iterator &it)const
    		{
    			return _ptr - it._ptr;
    		}
    		void operator++() { _ptr++; }
    		void operator--() { _ptr--; }
    		T& operator*() { return *_ptr; }
    	private:
    		T *_ptr; // size
    	};
    	iterator begin() { return iterator(_first._ptr); }
    	iterator end() { return iterator(_first._ptr + size()); }
    	
    	// 给it迭代器的位置,插入一个值为val的对象,返回插入位置的新的迭代器
    	iterator insert(iterator it, const T &val)
    	{
    		// _first    _last [_first, _last]     _end
    		if (_last == _end)
    		{
    			int offset = it._ptr - _first._ptr;
    			resize();
    			it._ptr = _first._ptr + offset;
    		}
    
    		for (T *p = _last._ptr-1; p >= it._ptr; --p)
    		{
    			mAllocator.construct(p+1, *p);
    			mAllocator.destroy(p);
    		}
    		++_last;
    		mAllocator.construct(it._ptr, val);
    		return it;
    	}
    
    	// 删除it迭代器指向的位置,返回删除位置的最新的迭代器
    	iterator erase(iterator it)  // it _ptr size:10
    	{
    		for (T *p = it._ptr; p < _last._ptr; ++p)
    		{
    			mAllocator.destroy(p);
    			mAllocator.construct(p, *(p+1));
    		}
    		--_last; // _ptr--  size--
    		return it;  // 为什么it没变,要进行返回
    	}
    private:
    	iterator _first; // 指向起始位置
    	iterator _last; // 最后一个元素的下一个位置
    	iterator _end; // 指向末尾的下一个位置
    	allocator mAllocator;  // 存储容器的空间配置器
    
    	// 容器内存2倍扩容
    	void resize()
    	{
    		if (_first._ptr == nullptr)
    		{
    			_first._ptr = mAllocator.allocate(sizeof(T));
    			_last._ptr = _first._ptr;
    			_end._ptr = _first._ptr + 1;
    		}
    		else
    		{
    			int size = _last._ptr - _first._ptr;
    			T *ptmp = mAllocator.allocate(2 * sizeof(T) * size);
    			for (int i = 0; i < size; ++i)
    			{
    				mAllocator.construct(ptmp+i, _first._ptr[i]);
    			}
    			
    			for (int i = 0; i < size; ++i)
    			{
    				mAllocator.destroy(_first._ptr + i);
    			}
    			mAllocator.deallocate(_first._ptr);
    			
    			_first._ptr = ptmp;
    			_last._ptr = _first._ptr + size;
    			_end._ptr = _last._ptr + size;
    		}
    	}
    };
    
    

    迭代器失效问题

    迭代器失效的问题归纳起来就两点:
    1>、不同容器的迭代器是不能进行比较的。
    2>、容器的元素进行增加删除操作后,原来的迭代器就会失效
    那应该怎么解决呢?就是要对迭代器进行实时进行更新
    如下代码:

    #include <vector>
    #include <iostream>
    int main()
    {
    	std::vector<int> vec1;
    	for (int i = 0; i < 20; ++i)
    	{
    		vec1.push_back(rand() % 100);
    	}
    
    	// 删除所有偶数
    	auto it = vec1.begin();
    	while (it != vec1.end())
    	{
    		if (*it % 2 == 0)
    		{
    			// 这里要对迭代器进行实时更新,否则容器元素改变,it迭代器失效!
    			it = vec1.erase(it);
    		}
    		else
    		{
    			++it;
    		}
    	}
    
    	for (int v : vec1)
    	{
    		std::cout << v << " ";
    	}
    	std::cout << std::endl;
    	return 0;
    }
    

    例子:vector中删除一个元素,会导致迭代器失效,具体看图:
    在这里插入图片描述
    如果我要删除这里面的3,结果正确后本来应该剩下1和4,但是vector里面的erase删除后,返回下一个位置的迭代器也就是第二个3,在it++后,直接跳过第二个3,在最后里面还有1 3 4,这就是迭代器失效。
    既然知道了失效,那应该怎么解决呢?就是要对迭代器进行实时进行更新

    1.继续使用库里的erase,接收返回值,但最后it++时,要分情况,代码如下:

    for(it = a.begin(); it != a.end;)
    	{
    		if(*it == 3)
    		{
    			it = array.erase(it);
    		}
    		else
    		{
    			it++;
    		}
    	}
    

    2.修改erase,给参数加上引用,重置it

    for(it = a.begin(); it != a.end;)
    	{
    		if(*it == 3)
    		{
    			array.erase(it);
    		}
    			it++;
    	}
    
    展开全文
  • C++ 迭代器 iterator

    2017-04-12 13:31:47
    1. 迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。 (1) 每种容器类型都定义了自己的迭代器类型,如vector: vector::iterator iter;这条语句定义了一个名为iter的变量,它的数据类型是由vector定义的...

    原文链接:http://www.cnblogs.com/yc_sunniwell/archive/2010/06/25/1764934.html


    1. 迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。

    (1) 每种容器类型都定义了自己的迭代器类型,如vector:

    vector<int>::iterator iter;这条语句定义了一个名为iter的变量,它的数据类型是由vector<int>定义的iterator类型。


    (2) 使用迭代器读取vector中的每一个元素:
    vector<int> ivec(10,1);
    for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    {
    *iter=2; //使用 * 访问迭代器所指向的元素

    }


    (3)const_iterator:
    只能读取容器中的元素,而不能修改。
    for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
    {
    cout<<*citer;
    //*citer=3; error

    }

    vector<int>::const_iterator 和 const vector<int>::iterator的区别
    const vector<int>::iterator newiter=ivec.begin();
    *newiter=11; //可以修改指向容器的元素

    //newiter++; //迭代器本身不能被修改 


    (4) iterator的算术操作:
    iterator除了进行++,--操作,可以将iter+n,iter-n赋给一个新的iteraor对象。还可以使用一个iterator减去另外一个iterator.
    const vector<int>::iterator newiter=ivec.begin();
    vector<int>::iterator newiter2=ivec.end();

    cout<<"\n"<<newiter2-newiter; 


    一個很典型使用vector的STL程式:
    1 #include <vector>
    2 #include <iostream>

    4 using namespace std;

    6 int main() {
    7 vector<int> ivec;
    8 ivec.push_back(1);
    9 ivec.push_back(2);
    10 ivec.push_back(3);
    11 ivec.push_back(4);
    12  
    13 for(vector<int>::iterator iter = ivec.begin();1. iter != ivec.end(); ++iter)
    14 cout << *iter << endl;

    15 }


    2. Iterator(迭代器)模式
    一、概述
        Iterator(迭代器)模式又称Cursor(游标)模式,用于提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。或者这样说可能更容易理解:Iterator模式是运用于聚合对象的一种模式,通过运用该模式,使得我们可以在不知道对象内部表示的情况下,按照一定顺序(由iterator提供的方法)访问聚合对象中的各个元素。
        由于Iterator模式的以上特性:与聚合对象耦合,在一定程度上限制了它的广泛运用,一般仅用于底层聚合支持类,如STL的list、vector、stack等容器类及ostream_iterator等扩展iterator。


        根据STL中的分类,iterator包括:
    Input Iterator:只能单步向前迭代元素,不允许修改由该类迭代器引用的元素。
    Output Iterator:该类迭代器和Input Iterator极其相似,也只能单步向前迭代元素,不同的是该类迭代器对元素只有写的权力。
    Forward Iterator:该类迭代器可以在一个正确的区间中进行读写操作,它拥有Input Iterator的所有特性,和Output Iterator的部分特性,以及单步向前迭代元素的能力。
    Bidirectional Iterator:该类迭代器是在Forward Iterator的基础上提供了单步向后迭代元素的能力。
    Random Access Iterator:该类迭代器能完成上面所有迭代器的工作,它自己独有的特性就是可以像指针那样进行算术计算,而不是仅仅只有单步向前或向后迭代。
        这五类迭代器的从属关系,如下图所示,其中箭头A→B表示,A是B的强化类型,这也说明了如果一个算法要求B,那么A也可以应用于其中。

    input output
          \ /
    forward
           |
    bidirectional
           |
    random access
     图1、五种迭代器之间的关系


        vector 和deque提供的是RandomAccessIterator,list提供的是BidirectionalIterator,set和map提供的 iterators是 ForwardIterator,关于STL中iterator迭代器的操作如下:
    说明:每种迭代器均可进行包括表中前一种迭代器可进行的操作。
    迭代器操作                      说明
    (1)所有迭代器
    p++                              后置自增迭代器
    ++p                              前置自增迭代器
    (2)输入迭代器
    *p                                 复引用迭代器,作为右值
    p=p1                             将一个迭代器赋给另一个迭代器
    p==p1                           比较迭代器的相等性
    p!=p1                            比较迭代器的不等性
    (3)输出迭代器
    *p                                 复引用迭代器,作为左值
    p=p1                             将一个迭代器赋给另一个迭代器
    (4)正向迭代器
    提供输入输出迭代器的所有功能
    (5)双向迭代器
    --p                                前置自减迭代器
    p--                                后置自减迭代器
    (6)随机迭代器
    p+=i                              将迭代器递增i位
    p-=i                               将迭代器递减i位
    p+i                                在p位加i位后的迭代器
    p-i                                 在p位减i位后的迭代器
    p[i]                                返回p位元素偏离i位的元素引用
    p<p1                             如果迭代器p的位置在p1前,返回true,否则返回false
    p<=p1                           p的位置在p1的前面或同一位置时返回true,否则返回false
    p>p1                             如果迭代器p的位置在p1后,返回true,否则返回false
    p>=p1                           p的位置在p1的后面或同一位置时返回true,否则返回false

    只有顺序容器和关联容器支持迭代器遍历,各容器支持的迭代器的类别如下:
    容器                 支持的迭代器类别            容器               支持的迭代器类别            容器                 支持的迭代器类别
    vector              随机访问                      deque              随机访问                       list                   双向
    set                   双向                            multiset            双向                           map                 双向
    multimap          双向                             stack                不支持                        queue              不支持
    priority_queue   不支持

    二、结构
    Iterator模式的结构如下图所示:


    图2、Iterator模式类图示意


    三、应用
        Iterator模式有三个重要的作用:
    1)它支持以不同的方式遍历一个聚合.复杂的聚合可用多种方式进行遍历,如二叉树的遍历,可以采用前序、中序或后序遍历。迭代器模式使得改变遍历算法变得很容易: 仅需用一个不同的迭代器的实例代替原先的实例即可,你也可以自己定义迭代器的子类以支持新的遍历,或者可以在遍历中增加一些逻辑,如有条件的遍历等。
    2)迭代器简化了聚合的接口. 有了迭代器的遍历接口,聚合本身就不再需要类似的遍历接口了,这样就简化了聚合的接口。
    3)在同一个聚合上可以有多个遍历 每个迭代器保持它自己的遍历状态,因此你可以同时进行多个遍历。
    4)此外,Iterator模式可以为遍历不同的聚合结构(需拥有相同的基类)提供一个统一的接口,即支持多态迭代。
        简单说来,迭代器模式也是Delegate原则的一个应用,它将对集合进行遍历的功能封装成独立的Iterator,不但简化了集合的接口,也使得修改、增加遍历方式变得简单。从这一点讲,该模式与Bridge模式、Strategy模式有一定的相似性,但Iterator模式所讨论的问题与集合密切相关, 造成在Iterator在实现上具有一定的特殊性,具体将在示例部分进行讨论。


    四、优缺点
         正如前面所说,与集合密切相关,限制了 Iterator模式的广泛使用,就个人而言,我不大认同将Iterator作为模式提出的观点,但它又确实符合模式“经常出现的特定问题的解决方案”的 特质,以至于我又不得不承认它是个模式。在一般的底层集合支持类中,我们往往不愿“避轻就重”将集合设计成集合 + Iterator 的形式,而是将遍历的功能直接交由集合完成,以免犯了“过度设计”的诟病,但是,如果我们的集合类确实需要支持多种遍历方式(仅此一点仍不一定需要考虑 Iterator模式,直接交由集合完成往往更方便),或者,为了与系统提供或使用的其它机制,如STL算法,保持一致时,Iterator模式才值得考虑。


    五、举例
        可以考虑使用两种方式来实现Iterator模式:内嵌类或者友元类。通常迭代类需访问集合类中的内部数据结构,为此,可在集合类中设置迭代类为friend class,但这不利于添加新的迭代类,因为需要修改集合类,添加friend class语句。也可以在抽象迭代类中定义protected型的存取集合类内部数据的函数,这样迭代子类就可以访问集合类数据了,这种方式比较容易添加新的迭代方式,但这种方式也存在明显的缺点:这些函数只能用于特定聚合类,并且,不可避免造成代码更加复杂。
        STL的list::iterator、deque::iterator、rbtree::iterator等采用的都是外部Iterator类的形式,虽然STL的集合类的iterator分散在各个集合类中,但由于各Iterator类具有相同的基类,保持了相同的对外的接口(包括一些traits及tags等,感兴趣者请认真阅读参考1、2),从而使得它们看起来仍然像一个整体,同时也使得应用algorithm成为可能。我们如果要扩展STL的iterator,也需要注意这一点,否则,我们扩展的iterator将可能无法应用于各algorithm。
    以下是一个遍历二叉树的Iterator的例子,为了方便支持多种遍历方式,并便于遍历方式的扩展,其中还使用了Strategy模式(见笔记21):
    (注:1、虽然下面这个示例是本系列所有示例中花费我时间最多的一个,但我不得不承认,它非常不完善,感兴趣的朋友,可以考虑参考下面的参考材料将其补充完善,或提出宝贵改进意见。2、 我本想考虑将其封装成与STL风格一致的形式,使得我们遍历二叉树必须通过Iterator来进行,但由于二叉树在结构上较线性存储结构复杂,使访问必须 通过Iterator来进行,但这不可避免使得BinaryTree的访问变得异常麻烦,在具体应用中还需要认真考虑。3、以下只提供了Inorder<中序>遍历iterator的实现。)



    展开全文
  • C++ 迭代器iterator

    2016-04-07 12:13:00
    迭代器与容器 迭代器与泛型 转载于:https://www.cnblogs.com/yyx920702/p/5362969.html

    迭代器与容器

    迭代器与泛型

    转载于:https://www.cnblogs.com/yyx920702/p/5362969.html

    展开全文
  • C++ 迭代器iterator的实现原理

    千次阅读 2020-01-03 09:31:03
    文章目录C++ 迭代器iterator的实现原理1. list类1.1 ListItem1.2 list类2. iterator3. 使用4. 总结 C++ 迭代器iterator的实现原理 在经典的设计模式中,有一种迭代器模式,定义为:提供一个对象来顺序访问聚合对象中...
  • C++ 迭代器iterator 小结

    2020-05-15 23:11:15
    C++中的迭代器Iteratoriterator概念和定义按照功能的定义:遍历vector代码示例容器与其迭代器功能迭代器的辅助函数 之前对C++中的iterator一直只有比较笼统的认识,由python中的迭代器知识所拟出来的浅薄印象,今天...
  • C++迭代器iterator详解

    千次阅读 多人点赞 2019-04-12 01:37:52
    目录迭代器概念iterator迭代器实现容器迭代器失效问题const_iterator迭代器实现reverse_iterator迭代器实现const_reverse_iterator迭代器实现insert插入型迭代器迭代器 迭代器概念 最近有人春招面试互联网大...
  • C++迭代器 iterator详解

    千次阅读 2020-04-05 19:31:26
    要访问顺序容器和关联容器中的元素,需要通过“迭代器iterator)”进行。迭代器是一个变量,相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素,通过迭代器就可以读写它指向的元素。从这一点...
  • 迭代器Iterator的分类: 迭代器可以分为不同的种类,这是因为他们使用不同的算法、不同的要求附加在其身上。例如,find()算法需要一个可以递增的迭代器,而reverse()算法需要一个可以递减的迭代器等。总之,在STL和...
  • 相似之处 1.指针和iterator都支持与整数进行+,-运算,而且其含义都是从当前位置向前或者向后移动n个位置 2.指针和iterator都...指针是C语言里面就有的东西,而迭代器C++里面才有的。 以下转自:https://blog.c...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,100
精华内容 1,240
关键字:

c++迭代器iterator

c++ 订阅