数据结构1.2 迭代器的实现

迭代器

实现原理为设计一个内部类封装指针，为这个内部类实现：

• *重载：用于取元素
• ++重载：用于遍历“下一个”
• ==/!=重载：用于判断是否已经结尾

除此之外，作为容器，应该提供：
begin/end方法：他们分别返回指向最开始的迭代器，以及指向结束元素的迭代器。方便遍历。
vector的迭代器实现代码：

#pragma once
#include <stdlib.h>
#include <string.h>

#define ty int

class CMyVector
{
public:
	CMyVector()
	{
		m_pDataAry = new ty[5];
		m_nCount = 0;
		m_nCapacity = 5;
	}
	~CMyVector()
	{

	}

	ty * m_pDataAry;
	int m_nCount; //当前元素个数
	int m_nCapacity; //当前容量大小24

	int size()
	{
		return m_nCount;
	}

	bool empty()
	{
		return (m_nCount == 0) ? true : false;
	}

	void pop_back()
	{
		if (m_nCount == 0)
		{
			return;
		}

		m_nCount--;
		return;
	}

	ty& operator[](int index)
	{
		return m_pDataAry[index];
	}

	ty front()
	{
		return m_pDataAry[0];
	}

	ty back()
	{
		return m_pDataAry[m_nCount - 1];
	}

	void push_back(ty item)
	{
		if (m_nCount + 1 > m_nCapacity)
		{
			ty* pOld = m_pDataAry;

			m_pDataAry = new ty[m_nCapacity * 2];
			//check...
			memcpy(m_pDataAry, pOld, m_nCapacity*sizeof(ty));
			if (pOld)
			{
				delete[] pOld;
				pOld = nullptr;
			}
			m_nCapacity *= 2;
		}

		m_pDataAry[m_nCount] = item; //注意拷贝构造
		m_nCount++;
	}

	struct iterator
	{
		ty* m_pData;
		iterator(ty* pObj) :m_pData(pObj)
		{

		}

		bool operator==(iterator& otherObj)
		{
			return m_pData == otherObj.m_pData;
		}



		bool operator != (iterator &otherObj)
		{
			return m_pData != otherObj.m_pData;
		}


		ty& operator*()
		{
			return *m_pData;
		}


		iterator operator++(int)
		{
			m_pData++; return m_pData;
			//类型是ty*，与iterator不符
			//但是iterator有构造：iterator(ty* pObj)
			//编译器会尝试把当前不符合的遍历，作为构造的参数
			//去自动构造
		}
	};


	iterator begin()
	{
		return &m_pDataAry[0];
	}


	iterator end()
	{
		return &m_pDataAry[m_nCount];
	}
};