这里介绍的4中迭代器是标准迭代器之外的类型。

插入迭代器

由于STL的算法不能直接改变容器的结构，而有些时候确实需要对容器进行数据插入，此时应该使用插入迭代器。总共有3类。

insert指定位置插入类型

该类迭代器可以使算法在容器的指定位置进行数据的插入，也可以是end()位置。

std::insert_iterator

这个迭代器经常用于让算法在容器的特定位置进行数据插入。简单的使用实例：

#include <iostream>
#include <iterator>
#include <list>
#include <algorithm>
using std::list;
using std::insert_iterator;
using std::copy;
using std::advance;
using std::cout;

int main() {
    list<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }

    list<int>::iterator it = foo.begin();
    advance(it, 3);  // 后移3个迭代器位置
	// 在容器的指定迭代器处进行插入
    insert_iterator<list<int>>insert_it(foo, it);
    copy(bar.begin(), bar.end(), insert_it);

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}

std::insert

template <class Container>
  insert_iterator<Container> inserter (Container& x, typename Container::iterator it);

用于构造一个insert_iterator类型的插入迭代器。使用方式类似于上面的std::insert_iterator迭代器。

#include <iostream>
#include <iterator>
#include <list>
#include <algorithm>
using std::list;
using std::inserter;
using std::copy;
using std::advance;
using std::cout;

int main() {
    list<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }

    list<int>::iterator it = foo.begin();
    advance(it, 3);
	// 直接在指定位置上进行构造
    copy(bar.begin(), bar.end(), inserter(foo, it));

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}

back_insert尾部位置插入类型

该类迭代器让算法在容器的尾部进行数据插入，但是容器必须支持push_back操作。一般都是标准容器，比如：vector、deque和list等。

std::back_insert_iterator

用于构造尾部插入迭代器类型

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using std::vector;
using std::back_insert_iterator;
using std::copy;
using std::advance;
using std::cout;

int main() {
    vector<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }
    // 定义迭代器类型
    back_insert_iterator<vector<int>> back_it(foo);
    copy(bar.begin(), bar.end(), back_it);

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}

std::back_inserter

template <class Container>
  back_insert_iterator<Container> back_inserter (Container& x);

用于构造一个尾部插入迭代器。
代码实例：

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using std::vector;
using std::back_inserter;
using std::copy;
using std::advance;
using std::cout;

int main() {
    vector<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }
	// 直接构造
    copy(bar.begin(), bar.end(), back_inserter(foo));

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}

front_insert类型

该类迭代器是在容器的头部进行插入数据，容器需要有push_front成员函数。注意插入后的顺序！！！

std::front_insert_iterator

这个迭代器类型允许在头部位置进行数据插入。

#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using std::deque;
using std::front_insert_iterator;
using std::copy;
using std::cout;

int main() {
    deque<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }

    front_insert_iterator<deque<int>>front_it(foo);
    copy(bar.begin(), bar.end(), front_it);

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}
/*
输出，注意顺序！！！！！
foo:50 40 30 20 10 1 2 3 4 5
*/

std::front_inserter

template <class Container>
  front_insert_iterator<Container> front_inserter (Container& x);

构造一个头部插入的迭代器。

#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using std::deque;
using std::front_inserter;
using std::copy;
using std::cout;

int main() {
    deque<int>foo, bar;
    for(int i = 1; i <= 5; ++i) {
        foo.push_back(i);
        bar.push_back(i * 10);
    }

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

    cout << "foo:";
    for(const auto& v : foo) {
        cout << ' ' << v;
    }
    cout << "\n";

    return 0;
}
/*
输出，注意顺序！！！！！
foo:50 40 30 20 10 1 2 3 4 5
*/

移动迭代器

调用这个迭代器，相当于把数据移动到一个容器中，操纵的数据对象需要支持std::move移动操作。

std::move_iterator

#include <iostream>
#include <iterator>
#include <vector>
#include  <string>
#include <algorithm>
using std::vector;
using std::string;
using std::iterator;
using std::move_iterator;
using std::copy;
using std::cout;

int main() {
    std::vector<std::string> foo (3);
    std::vector<std::string> bar {"one", "two", "three"};

    using Iter = vector<string>::iterator;
    copy(move_iterator<Iter>(bar.begin()),
         move_iterator<Iter>(bar.end()),
         foo.begin());

    bar.clear();  // 数据被移动了，所以要清空

    cout << "foo:";
    for(const auto& s : foo) {
        cout << ' ' << s;
    }
    cout << "\n";
    return 0;
}
/*
输出：
foo: one two three
*/

std::make_move_iterator

template <class Iterator>
  move_iterator<Iterator> make_move_iterator (Iterator it);

用于构造一个移动迭代器。

#include <iostream>
#include <iterator>
#include <vector>
#include  <string>
#include <algorithm>
using std::vector;
using std::string;
using std::iterator;
using std::make_move_iterator;
using std::copy;
using std::cout;

int main() {
    std::vector<std::string> foo (3);
    std::vector<std::string> bar {"one", "two", "three"};

    // 在这里直接构造
    copy(make_move_iterator(bar.begin()),
         make_move_iterator(bar.end()),
         foo.begin());

    bar.clear();  // 数据被移动了，所以要清空

    cout << "foo:";
    for(const auto& s : foo) {
        cout << ' ' << s;
    }
    cout << "\n";
    return 0;
}

反向迭代器

向后移动的迭代器，除了forward_list之外的标准库容器都有反向迭代器。

调用的方式是rbegin()、rend()、crbegind()和crend()。

流迭代器

绑定到输入输出流上，遍历所有与IO有关的流。暂时未用到。

C++的迭代器