泛型3(迭代器)

除了为每个容器定义的迭代器之外，标准库在头文件 iterator 中还定义了额外几种迭代器。这些迭代器包括以下几种：

插入迭代器：这些迭代器被绑定到一个容器上，可用来向容器插入元素

流迭代器：这些迭代器被绑定到输入或输出流上，可用来变量所有管理的 IO 流

反向迭代器：这些迭代器向后而不是向前移动。除了 forward_list 之外的标准库容器都有反向迭代器

移动迭代器：这些专用的迭代器不是拷贝其中的元素，而是移动它们。

插入迭代器(back_inserter/front_inserter/inserter)：

#include <iostream>
#include <algorithm>
#include <iterator>    
#include <list>
using namespace std;

int main(void){
    list<int> lst = {1, 2, 3, 4, 5};
    list<int> lst1, lst2, lst3;//空list
    
    copy(lst.cbegin(), lst.cend(), front_inserter(lst1));
    for(const auto &indx : lst1){
        cout << indx << " ";
    }
    cout << endl;//5 4 3 2 1

    copy(lst.cbegin(), lst.cend(), back_inserter(lst2));
    for(const auto &indx : lst2){
        cout << indx << " ";
    }
    cout << endl;//1 2 3 4 5

    copy(lst.cbegin(), lst.cend(), inserter(lst3, lst3.begin()));
    for(const auto &indx : lst3){
        cout << indx << " ";
    }
    cout << endl;//1 2 3 4 5

    return 0;
}

注意：它们是迭代器适配器。back_inserter、front_inserter 和 inserter 分别会调用 push_back、push_front 和 insert，因此只有在容器支持 push_back 的情况下我们才可以使用 back_inserter，容器支持 push_front 的情况下我们才可以使用 front_inserter，容器支持 insert 的情况下才可以调用 inserter

在插入过程中，back_inserter 总是将新元素插入当前容器尾后迭代器之前，front_inserter 总是将新元素插入当前迭代器首元素之前的位置。而当调用 inserter(c, iter) 时，我们得到一个迭代器，接下来使用它时，会将元素插入到 iter 原来所指向的元素之前的位置。即，如果 it 是由 inserter 生成的迭代器，则：

*it = val；

其效果于下下面代码一样：

it = c.insert(it, val)；// it 指向新加入的元素

++it；// 递增 it 使他指向原来的元素

iostream 迭代器：

虽然 iostream 不是迭代器，但标准库定义了可以用于这些 IO 类型对象的迭代器。istream_iterator 读取输入流，ostream_iterator 向一个输出流写数据。这些迭代器将它们对于的流当作一个特定类型的元素序列来处理。通过使用流迭代器，我们可以用泛型算法从流对象读取数据以及向其写入数据。

istream_iterator 操作：

当创建一个流迭代器时，必须指定迭代器将要读写的对象类型。一个 istream_iterator 使用 >> 来读取流。因此，istream_iterator 要读取的类型必须定义了输入运算符。反之亦然(我们可以为任何定义了输入运算符的类型创建 istream_iterator 对象)。当创建一个 istream_iterator 时，我们可以将它绑定到一个流。也可以默认初始化迭代器，这样就创建了一个可以当作尾后值使用的迭代器：

    istream_iterator<int> int_it(cin);//从cin读取int
    istream_iterator<int> int_eof;//尾后迭代器

    ifstream in("afile");
    istream_iterator<string> str_it(in);//从afile读取字符串

用 istream_iterator 从标准输入读取数据并存入一个 vector：

vector<int> v;
    istream_iterator<int> in_iter(cin);//从cin读取int
    istream_iterator<int> eof;//istream尾后迭代器
    while(in_iter != eof){//当有数据可读时
        //后置递增运算读取流,返回迭代器的旧值
        v.push_back(*in_iter++);//解引用迭代器,获得从流读取的前一个值
    }
    for(const auto &indx : v){
        cout << indx << " ";
    }
    cout << endl;

注意：对于一个绑定到流的迭代器，一旦其关联的流遇到文件尾或遇到 IO 错误，迭代器就与尾后迭代器相等

用流迭代器直接构造容器：

istream_iterator<int> in(cin);
    istream_iterator<int> ed;
    vector<int> vec(in, ed);
    for(const auto &indx : vec){
        cout << indx << " ";
    }
    cout << endl;

注意：这个构造函数从 cin 中读取数据，直至遇到文件尾或者遇到一个不是 int 的数据为止

使用算法操作流迭代器：

由于算法使用迭代器操作来处理数据，而流迭代器又至少支持某些迭代器的操作，因此我们至少可以使用某些算法类操作流迭代器。如，对一对 istream_iterator 来调用 accumulate：

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

int main(void){
    istream_iterator<int> in(cin), eof;
    cout << accumulate(in, eof, 0) << endl;

    return 0;
}

istream_iterator 允许使用懒惰求值：

当我们将一个 istream_iterator 绑定到一个流时，标准库并不能保证迭代器立即从流读取数据。具体实现可以推迟从流中读取数据，直到我们使用迭代器时才真正读取。标准库中的实现保证的是，在我们第一次解引用迭代器之前，从流中读取数据的操作已经完成。对于大多数程序来说，立即读取还是推迟读取没什么差别。但是，如果我们创建了一个 istream_iterator，没有使用就销毁了，或者我们正在从两个不同的对象同步读取一个流，那么何时读取可能就很重要了~

ostream_iterator 操作：

 我们可以对任何具有输出运算符的类定义 ostream_iterator。当创建一个 ostream_iterator 时，我们可以提供(可选的)第二参数，它是一个字符串，在输出每个元素后都会打印此字符串。此字符串必须是一个 c 风格字符串。必须将 ostream_iterator 绑定到一个指定的流，不允许空的或表示尾后位置的 ostream_iterator。

用 ostream_iterator 来输出值的序列：

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

int main(void){
    vector<int> vec = {1, 2, 3, 4, 45, 5, 6};

    ostream_iterator<int> out_iter(cout, " ");
    for(const auto &e : vec){
        *out_iter++ = e;//赋值语句实际上将元素写到cout
    }
    cout << endl;//1 2 3 4 45 5 6

    return 0;
}

值得注意的是，当我们向 out_iter 赋值时，可以忽略解引用和递增运算。即，上面代码可以写成下面的形式：

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

int main(void){
    vector<int> vec = {1, 2, 3, 4, 45, 5, 6};

    ostream_iterator<int> out_iter(cout, " ");
    for(const auto &e : vec){
        out_iter = e;//赋值语句将元素写到cout
    }
    cout << endl;//1 2 3 4 45 5 6

    return 0;
}

但是对于 istream_iterator 是不能这样操作的~

运算符 * 和 ++ 实际上对 ostream_iterator 对象不做任何事情，因此忽略它们对我们的程序没有任何影响。但是最好使用第一种写法，这此种写法中，ostream_iterator 与其它迭代器的使用保持一致。更容易修改，可读性也更好~

通过调用 copy 来打印容器中的元素：

#include <iostream>
#include <iterator>
#include <array>
using namespace std;

int main(void){
    array<int, 5> a = {1, 2, 3, 4, 5};
    ostream_iterator<int> out(cout, " ");
    copy(a.begin(), a.end(), out);//将a中元素拷贝到out,实际上就是将a中元素写到cout
    cout << endl;//1 2 3 4 5

    return 0;
}

使用流迭代器处理类类型：

我们可以为任何定义了输入运算符的类型创建 istream_iterator 对象。类似的，只要类型有输出运算符我们就可以为其定义 ostream_iterator：

#include <iostream>
#include <list>
#include <iterator>
using namespace std;

class gel{
friend istream& operator>>(istream&, gel&);//将>>重载为gel的友元函数
friend ostream& operator<<(ostream&, const gel&);//将<<重载为gel的友元函数

private:
    int x, y, z;

public:
    gel(int a, int b, int c) : x(a), y(b), z(c) {}
    gel(int a, int b) : gel(a, b, 0) {}
    gel(int a) : gel(a, 0, 0) {}
    gel() : gel(0, 0, 0) {}
    ~gel(){}
};

istream& operator>>(istream &is, gel &it) {
    is >> it.x >> it.y >> it.z;
    return is;
}

ostream& operator<<(ostream &os, const gel &it){
    os << it.x << " " << it.y << " " << it.z;
    return os;
}

int main(void){
    istream_iterator<gel> is(cin), eof;
    ostream_iterator<gel> os(cout, "
");
    list<gel> l;

    while(is != eof){
        l.push_back(*is++);//解引用迭代器,获得从流读取的前一个值
    }

    for(const auto &indx : l) {
        *os++ = indx;//将indx拷贝赋值给os,即将indx写到cout
    }
    cout << endl;

    return 0;
}

注意：只有重载了 >> / << 的类类型才能创建 istream_iterator 或 ostream_iterator 对象

用流迭代器读写文件：

#include <iostream>
#include <fstream>
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;

const char *filename = "D:\code\c++\ac29.txt";

int main(void){

    // 从屏幕读到vec中
    istream_iterator<string> in(cin), in_eof;
    vector<string> vec(in, in_eof);

    //从vec写到文件ac29.txt中
    ofstream out_file(filename);//用只写的方式打开文件
    ostream_iterator<string> out_file_it(out_file, " ");
    for(const auto &indx : vec){
        *out_file_it++ = indx;
    }

    out_file.close();//后面还要对filename文件进行操作,所以一定要关闭out_file文件流

    //从文件ac29.txt中读到ved中
    ifstream in_file(filename);//用只读的方式打开文件
    istream_iterator<string> in_file_it(in_file), in_file_eof;
    vector<string> ved(in_file_it, in_file_eof);

    in_file.close();//养成用完就关闭文件流的好习惯~

    //比较vec和ved中的内容是否相同
    cout << equal(vec.cbegin(), vec.cend(), ved.cbegin()) << endl;
    return 0;  
}