c++ primer（第五版）笔记 第十章 泛型算法（4）

// istream_iterator 操作
// istream_iterator<T> in(is)	in 从输入流 is 中读取类型为 T 的值
// istream_iterator<T> end		表示尾后位置
// in1 == in2		in1 和 in2 必须读取相同类型，如果他们都是尾后迭代器，或绑定到相同的输入，则相等
// in1 != in2
// *in			返回流中读取的值
// in->mem		相当于 (*in).mem
// ++in	返回一个自增后的迭代器引用
// in++	返回原迭代器的值


// ostream_iterator<T> out(os)		out 将类型为 T 的值输出到 os
// ostream_iterator<T> out(os, d)	d 是一个C风格字符串，在输出的每个值后添加
// out = val;		将 val 写入到 out 绑定的输出流中，其类型必须与 out 写的类型兼容
// *out, ++out, out++	存在，但无实际意义，都返回 out

// 反向迭代器，必须支持自增和自减，不支持 forward_list 和流迭代器
	// rbegin() 		指向尾元素的反向迭代器
	// crbegin() 	指向尾元素的 const 反向迭代器
	// rend() 			指向首前位置的反向迭代器
	// crend()		指向首前位置的 const 反向迭代器
	// 自增和自减，移动方向与普通迭代器方向相反
#include<iostream>
#include<string>
#include<vector>
#include<iterator>
#include<fstream>
#include<algorithm>
using std::vector;
using std::string;
using std::cout;
using std::endl;
using std::ostream_iterator;
using std::istream_iterator;
using std::ifstream;
using std::ofstream;

void read_from_file_to_c();
void read_from_file_to_c2(const string &, const string &, const string &);
int main()
{
	read_from_file_to_c();
	read_from_file_to_c2("number", "odd", "even");
}

// 从名为 123的文件中读取数据，然后写入 vector,输出显式
void read_from_file_to_c()
{
	//创建文件流
	ifstream if_in("123");
	//绑定输入流迭代器
	istream_iterator<string> in(if_in), eof;
	//绑定输出流迭代器
	ostream_iterator<string> out(cout, " > ");
	//目标容器
	vector<string> vs;
	//循环写入
	while( in != eof)
		vs.push_back(*in++);
	//长度排序
	stable_sort(vs.begin(), vs.end(),[](string s1, string s2){ return s1.size() < s2.size();});
	//输出
	copy(vs.begin(), vs.end(), out);
	cout << endl;
}

// 从名为 file_in的文件中读取整型数据，然后根据奇偶分别写入 file_out_odd file_out_even
void read_from_file_to_c2(const string &file_in, const string &file_out_odd, const string &file_out_even)
{
	//创建文件流
	ifstream if_in(file_in);
	ofstream if_out_odd(file_out_odd), if_out_even(file_out_even);
	//绑定输入流迭代器
	istream_iterator<int> in(if_in), eof;
	//绑定输出流迭代器
	ostream_iterator<int> out_odd(if_out_odd, "\n"), out_even(if_out_even, " ");

	//循环写入
	while( in != eof)
	{
		int val = *in++;
		if( ( val) % 2)
			out_odd = val;
		else
			out_even = val;
	}
}
<pre name="code" class="cpp">// 根据算法对迭代器操作的要求分类：
	// 输入迭代器(input iterator),读取序列中的元素		只读，不写，单遍扫描，只能递增
		// 必须支持:
			// 比较两个迭代器的相等和不相等的运算符( ==  !=)
			// 用于推进迭代器的前置和后置递增运算符( ++)
			// 用于读取元素的解引用运算符( *)，只会出现在赋值运算的右侧
			// 箭头运算符，等价于 (*it).mem
		
	// 输出迭代器(output iterator)		只写，不读，单遍扫描，只能递增
		// 必须支持:
			// 用于推进迭代器的前置和后置递增运算符( ++)
			// 解引用运算符( *)，只会出现在赋值运算的左侧，向解引用的元素赋值，相当于将值写入它所指向的元素
	
	// 前向迭代器(forward iterator)		可读写，多遍扫描，只能递增
		// 支持输入输出的所有运算，但只能在序列中沿一个方向，可以多次读写同一个元素
		
	// 双向迭代器 (bidrectional iterator)      可读写，多遍扫描，可递增递减
		// 支持所有前向迭代器的运算，可正向反向读写序列中的元素，还支持前置后置递减
		
	// 随机访问迭代器(random-access iterator)  可读写，多遍扫描，支持全部迭代器运算
		// 比较两个迭代器相对位置的关系运算符 > >= < <=
		// 迭代器移位的整数加减 + += - -=
		// 两个迭代器之间的距离 -
		// 下表运算符 iter[i] 等价于 *(iter[i])
		

	// 算法的四种形式
		// alg(begin, end, other args)
		// alg(begin, end, dest, other args)
		// alg(begin, end, begin2, other args)
		// alg(begin, end, begin2, end2, other args)
		
	// 特定容器算法
		// list 和 forward_list 具有成员函数的算法
			// lst.merge(lst2)			lst2 并入 lst，2个列表必须是有序的, 合并后 lst2 为空，默认使用 < 运算符，也可以用 comp
			// lst.merge(lst2, comp)
			
			// lst.remove(val)			调用 erase 删除和 val 相等的元素或使 一元 pred 为真的每个元素
			// lst.remove_if(pred)			
			
			// lst.reverse()			反转序列
			
			// lst.sort()				使用 < 或 comp 排序
			// lst.sort(comp)
			
			// lst.unique()			调用 erase 删除同一个值的拷贝，使用 == 或 二元谓词
			// lst.unique(pred)
			
			// 链表独有算法 
				// lst.splice(args)	flst.splice_after(args)
				// args 可以是：
					// (p, lst2)		p 为 lst 的迭代器 或 flst的首前位置的迭代器，将 lst2 中的所有元素移动到 lst 的p之前的位置，或 flst 的p之后的位置，然后从 lfs2 中删除元素，lst2 必须与lst flst 类型相同，且不能是同一链表
					// (p, lst2, p2)	p2 是 lst2 中有效的迭代器，将p2指向的元素移动到  lst 的p之前的位置,或将 p2 之后的元素移动到 flst 的p之后的位置,可以是同一个链表
						
					// (p, lst2, b, e)	b e 为 lst2的有效范围，移动元素到 lst 或 flst,可以是同一个链表,但 p 不能指向 b e中的元素
					
			// 链表独有算法和通用算法的重要区别，链表版本的算法会改变底层的容器