<iterator>是C++标准程序库中的一个头文件，定义了C++ STL标准中的一些迭代器模板类，这些类都是以std::iterator为基类派生出来的。迭代器提供对集合(容器)元素的操作能力。迭代器提供的基本操作就是访问和遍历。迭代器模拟了C++中的指针，可以有++运算，用*(解引用算符，deference)或->算符来访问容器中的元素。容器中元素如果改变了所用内存，也不影响绑定的迭代器指向正确的位置。因此，迭代器实际上更像是句柄(handler)。迭代器允许C++程序以统一的方式处理不同的数据结构。迭代器充当容器和通用算法之间的中介。而不是对特定数据类型进行操作，算法被定义为在一个迭代器类型指定的范围内运行。任何满足迭代器要求的数据结构都可以通过算法进行操作。

STL的迭代器实现了设计模式中的”迭代器模式”，即顺序访问一个聚合中的元素，又不暴露聚合的实现细节。

迭代器支持以不同方法遍历聚合类型。例如，对一颗树数据类型，可以有前序、中序、后序遍历的迭代器。同一个聚合类型的对象上，可以同时有多个迭代器，各自保持不同的遍历状态。在不同的聚合类型上实现的迭代器具有标准的对外接口，这给STL中的算法使用迭代器提供了可能。

一共支持五种迭代器：输入迭代器(*iter解引用后只能用作右值)、输出迭代器(*iter解引用后只能用作左值)、前向迭代器(具有输入迭代器、输出迭代器的所有功能，且可以反复遍历操作，支持对同一个元素的多次读写)、双向迭代器(是在前向迭代器的基础上，多了单步向后遍历的能力)、随机访问迭代器(在双向迭代器基础上，具有直接访问各数据元素的能力。随机迭代器增加了”迭代器算术运算”)。

std::input_iterator_tag：空类，标识一个迭代器的类别为输入迭代器。

std::output_iterator_tag：空类，标识一个迭代器的类别为输出迭代器。

std::forward_iterator_tag：空类，标识一个迭代器的类别为前向迭代器。

std::bidirectional_iterator_tag：空类，标识一个迭代器的类别为双向迭代器。

std::random_access_iterator_tag：空类，标识一个迭代器的类别为随机迭代器。

下面是从其它文章中copy的<iterator>测试代码，详细内容介绍可以参考对应的reference：

#include "iterator.hpp"
#include <iterator>
#include <iostream>
#include <typeinfo>
#include <list>
#include <vector>
#include <algorithm>
#include <deque>
#include <string>

// reference: http://www.cplusplus.com/reference/iterator/

namespace iterator_ {
///
class MyIterator : public std::iterator<std::input_iterator_tag, int>
{
public:
	MyIterator(int* x) :p(x) {}
	MyIterator(const MyIterator& mit) : p(mit.p) {}
	MyIterator& operator++() { ++p; return *this; }
	MyIterator operator++(int) { MyIterator tmp(*this); operator++(); return tmp; }
	bool operator==(const MyIterator& rhs) const { return p == rhs.p; }
	bool operator!=(const MyIterator& rhs) const { return p != rhs.p; }
	int& operator*() { return *p; }
private:
	int* p;
};

int test_iterator_1()
{
	// std::iterator: 迭代器基类
	int numbers[] = { 10, 20, 30, 40, 50 };
	MyIterator from(numbers);
	MyIterator until(numbers + 5);
	for (MyIterator it = from; it != until; it++)
		std::cout << *it << ' ';
	std::cout << '\n';

	return 0;
}

/
int test_iterator_2()
{
	// std::iterator_traits: 定义迭代器属性
	typedef std::iterator_traits<int*> traits;
	if (typeid(traits::iterator_category) == typeid(std::random_access_iterator_tag))
		std::cout << "int* is a random-access iterator" << std::endl;;

	return 0;
}

///
int test_iterator_3()
{
	// std::advance: 将迭代器推进到n个元素位置，可以是负值
	std::list<int> mylist;
	for (int i = 0; i<10; i++) mylist.push_back(i * 10);

	std::list<int>::iterator it = mylist.begin();

	std::advance(it, 5);

	std::cout << "The sixth element in mylist is: " << *it << '\n'; // 50

	return 0;
}


int test_iterator_4()
{
	// std::back_inserter: 构造一个在x的末尾插入新元素的后插入迭代器
	std::vector<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::copy(bar.begin(), bar.end(), std::back_inserter(foo));

	std::cout << "foo contains:";
	for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 1 2 3 4 5 10 20 30 40 50
	std::cout << '\n';

	return 0;
}

//
int test_iterator_5()
{
	// std::begin: 返回指向序列中第一个元素的迭代器
	// std::end: 返回指向序列中过去的最后一个元素的迭代器
	int foo[] = { 10, 20, 30, 40, 50 };
	std::vector<int> bar;

	// iterate foo: inserting into bar
	for (auto it = std::begin(foo); it != std::end(foo); ++it)
		bar.push_back(*it);

	// iterate bar: print contents:
	std::cout << "bar contains:";
	for (auto it = std::begin(bar); it != std::end(bar); ++it)
		std::cout << ' ' << *it; // 10 20 30 40 50
	std::cout << '\n';

	return 0;
}

//
int test_iterator_6()
{
	// std::distance: 计算first和last之间的元素数量
	std::list<int> mylist;
	for (int i = 0; i<10; i++) mylist.push_back(i * 10);

	std::list<int>::iterator first = mylist.begin();
	std::list<int>::iterator last = mylist.end();

	std::cout << "The distance is: " << std::distance(first, last) << '\n'; // 10

	return 0;
}


int test_iterator_7()
{
	// std::front_inserter: 构造一个前插入迭代器，在x的开头插入新元素
	std::deque<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::copy(bar.begin(), bar.end(), std::front_inserter(foo));

	std::cout << "foo contains:";
	for (std::deque<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 50 40 30 20 10 1 2 3 4 5
	std::cout << '\n';

	return 0;
}

//
int test_iterator_8()
{
	// std::inserter: 构造一个插入迭代器，从指向的位置开始，在连续的位置中插入新元素x
	std::list<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::list<int>::iterator it = foo.begin();
	std::advance(it, 3);

	std::copy(bar.begin(), bar.end(), std::inserter(foo, it));

	std::cout << "foo contains:";
	for (std::list<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 1 2 3 10 20 30 40 50 4 5
	std::cout << '\n';

	return 0;
}


int test_iterator_9()
{
	// std::make_move_iterator: 从it构造一个move_iterator对象
	std::vector<std::string> foo(3);
	std::vector<std::string> bar{ "one", "two", "three" };

	std::copy(std::make_move_iterator(bar.begin()), std::make_move_iterator(bar.end()), foo.begin());

	// bar now contains unspecified values; clear it:
	bar.clear();

	std::cout << "foo:";
	for (std::string& x : foo) std::cout << ' ' << x; // one two three
	std::cout << '\n';

	return 0;
}

//
int test_iterator_10()
{
	// std::next: 获取下一个元素的迭代器
	std::list<int> mylist;
	for (int i = 0; i<10; i++) mylist.push_back(i * 10);

	std::cout << "mylist:";
	std::for_each(mylist.begin(), std::next(mylist.begin(), 5), [](int x) {std::cout << ' ' << x; }); // 0 10 20 30 40 50

	std::cout << '\n';

	return 0;
}

//
int test_iterator_11()
{
	// std::prev: 获取前一个元素的迭代器
	std::list<int> mylist;
	for (int i = 0; i<10; i++) mylist.push_back(i * 10);

	std::cout << "The last element is " << *std::prev(mylist.end()) << '\n'; // 90

	return 0;
}


int test_iterator_12()
{
	// std::back_insert_iterator: 在容器末尾插入元素的迭代器
	std::vector<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::back_insert_iterator< std::vector<int> > back_it(foo);

	std::copy(bar.begin(), bar.end(), back_it);

	std::cout << "foo:";
	for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 1 2 3 4 5 10 20 30 40 50 
	std::cout << '\n';

	return 0;
}

///
int test_iterator_13()
{
	// std::front_insert_iterator: 在容器开头插入元素的迭代器
	std::deque<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::front_insert_iterator< std::deque<int> > front_it(foo);

	std::copy(bar.begin(), bar.end(), front_it);

	std::cout << "foo:";
	for (std::deque<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 50 40 30 20 10 1 2 3 4 5
	std::cout << '\n';

	return 0;
}

//
int test_iterator_14()
{
	// std::insert_iterator: 插入迭代器
	std::list<int> foo, bar;
	for (int i = 1; i <= 5; i++) {
		foo.push_back(i); bar.push_back(i * 10);
	}

	std::list<int>::iterator it = foo.begin();
	std::advance(it, 3);

	std::insert_iterator< std::list<int> > insert_it(foo, it);

	std::copy(bar.begin(), bar.end(), insert_it);

	std::cout << "foo:";
	for (std::list<int>::iterator it = foo.begin(); it != foo.end(); ++it)
		std::cout << ' ' << *it; // 1 2 3 10 20 30 40 50 4 5
	std::cout << '\n';

	return 0;
}

///
int test_iterator_15()
{
	// std::istreambuf_iterator: 输入流缓存迭代器
	std::istreambuf_iterator<char> eos;                    // end-of-range iterator
	std::istreambuf_iterator<char> iit(std::cin.rdbuf()); // stdin iterator
	std::string mystring;

	std::cout << "Please, enter your name: ";

	while (iit != eos && *iit != '\n') mystring += *iit++;

	std::cout << "Your name is " << mystring << ".\n";

	return 0;
}

///
int test_iterator_16()
{
	// std::istream_iterator: 从输入流读取连续元素的输入迭代器
	double value1, value2;
	std::cout << "Please, insert two values: ";

	std::istream_iterator<double> eos;              // end-of-stream iterator
	std::istream_iterator<double> iit(std::cin);   // stdin iterator

	if (iit != eos) value1 = *iit;

	++iit;
	if (iit != eos) value2 = *iit;

	std::cout << value1 << "*" << value2 << "=" << (value1*value2) << '\n';

	return 0;
}

///
int test_iterator_17()
{
	// std::move_iterator: 用于解引用(Dereference)到一个右值引用(Rvalue reference)的迭代器
	std::vector<std::string> foo(3);
	std::vector<std::string> bar{ "one", "two", "three" };

	typedef std::vector<std::string>::iterator Iter;

	std::copy(std::move_iterator<Iter>(bar.begin()), std::move_iterator<Iter>(bar.end()), foo.begin());

	// bar now contains unspecified values; clear it:
	bar.clear();

	std::cout << "foo:";
	for (std::string& x : foo) std::cout << ' ' << x; // one two three
	std::cout << '\n';

	return 0;
}

///
int test_iterator_18()
{
	// std::ostreambuf_iterator: 输出流缓存迭代器
	std::string mystring("Some text here...\n");
	std::ostreambuf_iterator<char> out_it(std::cout); // stdout iterator

	std::copy(mystring.begin(), mystring.end(), out_it); // Some text here...

	return 0;
}

/
int test_iterator_19()
{
	// std::ostream_iterator: 顺序写入输出流的输出迭代器
	std::vector<int> myvector;
	for (int i = 1; i<10; ++i) myvector.push_back(i * 10);

	std::ostream_iterator<int> out_it(std::cout, ", ");
	std::copy(myvector.begin(), myvector.end(), out_it); // 10, 20, 30, 40, 50, 60, 70, 80, 90, 

	return 0;
}

///
int test_iterator_20()
{
	// std::reverse_iterator: 反向迭代器
	std::vector<int> myvector;
	for (int i = 0; i<10; i++) myvector.push_back(i);

	typedef std::vector<int>::iterator iter_type;
							      // ? 0 1 2 3 4 5 6 7 8 9 ?
	iter_type from(myvector.begin());                     //   ^
							      //         ------>
	iter_type until(myvector.end());                      //                       ^
							      //
	std::reverse_iterator<iter_type> rev_until(from);     // ^
							      //         <------
	std::reverse_iterator<iter_type> rev_from(until);     //                     ^

	std::cout << "myvector:";
	while (rev_from != rev_until)
		std::cout << ' ' << *rev_from++; // 9 8 7 6 5 4 3 2 1 0
	std::cout << '\n';

	return 0;
}

} // namespace iterator_

GitHub：https://github.com/fengbingchun/Messy_Test