提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。
当一家公司发展到足够大，需要陆续的合并或收购其他公司，但保持原有公司的人力架构。对于总公司的HR，需要面对不同的人力系统，当要统计各子公司各部门的人力信息时，比较困难。每收购一家公司，都需要熟悉一套新的人力系统。但当每套人力系统对外暴露的统计方式一致时，HR就不需要关心各子公司具体的人力架构。

#include <iostream>
#include <string>
#include <vector>
#include <list>

class DepartMent;
class ConcreteCompanyA;
class ConcreteCompanyB;

// 迭代器基类
template<typename Type>
class Iterator
{
public:
	Iterator() {}
	virtual ~Iterator() {}
	virtual bool HasNext() = 0;
	virtual Type* Next() = 0;  //返回当前内容，并往后移动一步
};

template<typename Type1, typename Type2>
class ConCreteIterator : public Iterator<Type1>
{
public:
	ConCreteIterator(Type2* company, size_t size)
		: Iterator<Type1>(), m_company(company), m_cur(0), m_size(size)
	{

	}

	virtual ~ConCreteIterator()
	{

	}

	bool HasNext()
	{
		return m_cur < m_size;
	}

	Type1* Next()
	{
		return (*m_company)[m_cur++];
	}

private:
	Type2* m_company;
	size_t m_cur;
	size_t m_size;
};

class DepartMent
{
public:
	DepartMent(std::string name, int num) : m_name(name), m_employNum(num) {}
	~DepartMent() {}

	std::string Name()
	{
		return m_name;
	}

	int EmployNum()
	{
		return m_employNum;
	}

private:
	std::string m_name;
	int m_employNum;
};


// 公司基类
class Company
{
public:
	Company() {}
	virtual ~Company() {}
	virtual Iterator<DepartMent>* createIterator() = 0;
	virtual void AddDepartMent(DepartMent* departMent) = 0;
};

class ConcreteCompanyA : public Company
{
public:
	ConcreteCompanyA() {}

	~ConcreteCompanyA()
	{
		for (size_t i = 0; i < Size(); ++i)
		{
			delete m_departments[i];
		}
		m_departments.clear();
	}

	Iterator<DepartMent>* createIterator()
	{
		return new ConCreteIterator<DepartMent, ConcreteCompanyA>(this, m_departments.size());
	}

	void AddDepartMent(DepartMent* departMent)
	{
		m_departments.push_back(departMent);
	}

	size_t Size()
	{
		return m_departments.size();
	}

	DepartMent*& operator[](size_t index)
	{
		return m_departments[index];
	}

private:
	std::vector<DepartMent*> m_departments;
};

class ConcreteCompanyB : public Company
{
public:
	ConcreteCompanyB() {}

	~ConcreteCompanyB()
	{
		std::list<DepartMent*>::iterator iter;
		for (std::list<DepartMent*>::iterator iter = m_departments.begin(); iter != m_departments.end(); ++iter)
			delete *iter;
		m_departments.clear();
	}

	Iterator<DepartMent>* createIterator()
	{
		return new ConCreteIterator<DepartMent, ConcreteCompanyB>(this, m_departments.size());
	}

	void AddDepartMent(DepartMent* departMent)
	{
		m_departments.push_back(departMent);
	}

	size_t Size()
	{
		return m_departments.size();
	}

	DepartMent*& operator[](size_t index)
	{
		std::list<DepartMent*>::iterator iter;
		for (size_t i = 0; i < index; ++i)
			++iter;
		return *iter;
	}

private:
	std::list<DepartMent*> m_departments;
};

class HR
{
public:
	HR(std::vector<Company*> companys) : m_companys(companys) {}
	~HR() {}

	int EmployNums()
	{
		int num(0);
		for (size_t i = 0; i < m_companys.size(); ++i)
		{
			Iterator<DepartMent>* iter = m_companys[i]->createIterator();
			std::cout << "子公司 " << i << ": " << std::endl;
			while (iter->HasNext())
			{
				DepartMent* departMent = iter->Next();
				num += departMent->EmployNum();
				std::cout << departMent->Name() << "人数： " << departMent->EmployNum() << std::endl;
			}
		}

		return num;
	}
private:
	std::vector<Company*> m_companys;
};

void IteratorTest()
{
	Company* pCompanyA = new ConcreteCompanyA;
	Company* pCompanyB = new ConcreteCompanyB;

	std::vector<Company*> comVec;
	comVec.push_back(pCompanyA);
	comVec.push_back(pCompanyA);
	HR* pHR = new HR(comVec);

	pCompanyA->AddDepartMent(new DepartMent("Human Resources Department", 10));
	pCompanyA->AddDepartMent(new DepartMent("General Accounting Department", 5));
	pCompanyA->AddDepartMent(new DepartMent("Development Department", 30));

	pCompanyB->AddDepartMent(new DepartMent("Human Resources Department", 8));
	pCompanyB->AddDepartMent(new DepartMent("General Accounting Department", 2));
	pCompanyB->AddDepartMent(new DepartMent("Development Department", 30));

	std::cout << std::endl;
	std::cout << "总人数： " << pHR->EmployNums() << std::endl;

	delete pHR;
	delete pCompanyB;
	delete pCompanyA;

	pCompanyA = nullptr;
	pCompanyB = nullptr;
	pHR = nullptr;
}

int main()
{
	IteratorTest();
	getchar();
	return 0;
}