C++第十五天泛型算法和迭代器

/*

	泛型算法：
		
	泛型算法中，对指定数目的元素做写入运算，或者写到目标迭代器的算法，都不检查目标的大小是否足以存储要写入的元素

	流迭代器的限制：
		1.不可能从ostream_iterator对象读入，也不可能写道istream_iterator对象中。
		2.一旦给ostream_iterator对象赋了一个值，写入就提交了。赋值后，没有办法在改变这个值。此外，ostream_iterator对象中每个不同的值都只能只好输出一次。
		3.ostream_iterator没有->操作符。

	流迭代器不能反向遍历流，因此流迭代器不能创建反向迭代器。

	输入迭代器：可用于读取容器中的元素，但是不能报纸能支持容器的写入操作。输入迭代器必须至少提供下列支持：
		1.相等和不等操作符(==,!=),比较两个迭代器。
		2.前置和后置的自增运算(++)，使迭代器向前递进指向下一个元素。
		3.用于读取元素的解引用操作符(*)，此操作符只能出现在赋值运算的右操作数上。
		4.箭头操作符(-->),这是(*it).member的同义语，也就是说，对迭代器进行解引用来获取其所关联的对象的成员。
	(注：输入迭代器只能顺序使用，一旦输入迭代器自增了，就无法在用它检查之前的元素。要求在这个层次上提供支持的泛型算法包括find和accumulate。)

	输出迭代器：可视为与输入迭代器功能互补的迭代器，输出迭代器可用于向容器写入元素，但是不能保证能支持读取容器的内容。
		1.前置和后置的自增运算(++)，使迭代器向前递进指向下一个元素。
		2.解引用操作符(*)，此操作符只能出现在赋值运算的左操作数上。
	(注：使用输出迭代器时，对于指定的迭代器应该使用一次*运算，而且只能使用一次。)

	前向迭代器：读和写，只支持自增运算。

	双向迭代器：读和写，支持自增和自减运算。

	随机访问迭代器：提供在常量时间内访问容器任意位置的功能，除了支持双向迭代器的功能外，还支持下面的功能：
		1.关系操作符(<、<=、>、>=)，比较两个迭代器的相对位置。
		2.迭代器与整型树脂n之间的加法和减法操作符+、+=、-、-=，结果是迭代器在容器中向前或向后n个元素。
		3.两个迭代器之间的减法操作符(-)，得到两个迭代器间的距离。
		4.下标操作符(iter[n])，这是*(iter+n)的同义词。
*/

 
//泛型算法头文件
#include
//泛化的算术算法头文件
#include
#include
#include
#include
using namespace std;

int main(){
	vector vec;
	for(int i=0;i!=10;++i){
		vec.push_back(i);
	}
	//计算元素的和的只读算法
	int sum=accumulate(vec.begin(),vec.end(),0);
	cout<::iterator bsvec=vec.begin();
	while(bsvec!=vec.end()){
		cout<<*bsvec<<" ";
		++bsvec;
	}
	cout< vec2;
	for(int j=0;j!=10;++j){
		vec2.push_back(string(""+j));
	}
	//下面这句话报错,因为累加和的类型将是const char*，而string的加法擦欧洲哦符所使用的操作数分别是string和const char*类型，加法的结果将产生一个string对象，而不是const char*指针。
	string su=accumulate(vec2.begin(),vec2.end(),string(""));
	cout< words;
	for(string::size_type ij=0;ij!=sizeof(str)/sizeof(string);++ij){
		words.push_back(str[ij]);
	}
	//排序
	sort(words.begin(),words.end());

	//unique的使用：该算法删除响亮的重复元素，然后重新排列输入范围内的元素，并且返回一个迭代器，表示无重复的值范围的结束。
	vector::iterator end_unique=unique(words.begin(),words.end());
	words.erase(end_unique,words.end());
*/


	//顺序表容器
	list ilst,ilst2,ilst3;
	//为第一个顺序表容器赋值
	for(list::size_type ins=0;ins!=4;++ins){
		ilst.push_front(ins);
	}
	//通过迭代器访问容器的元素
	list::iterator beg=ilst.begin();
	while(beg!=ilst.end()){
		cout<<*beg<<" ";
		++beg;
	}
	cout<::iterator beg2=ilst2.begin();
	while(beg2!=ilst2.end()){
		cout<<*beg2<<" ";
		++beg2;
	}
	cout <::iterator beg3=ilst3.begin();
	while(beg3!=ilst3.end()){
		cout<<*beg3<<" ";
		++beg3;
	}
	cout < cin_it(cin);
	istream_iterator end_of_stream;
	//下面这句代码有错
	vector vecsa(cin_it,end_of_stream);
	//排序
	sort(vecsa.begin(),vecsa.end());
	//输出流迭代器
	ostream_iterator output(cout," ");
	//删除重复
	unique_copy(vecsa.begin(),vecsa.end(),output);
*/

	/*
	string sa[10]; //字符串数组为初始化？
	const vector file_names(sa,sa+6);
	//报未初始化错误。
	vector::iterator istsa=file_names.begin()+2;
	*/
 
	return 0;	

 }
 
/*

//泛型算法头文件
#include
//泛化的算术算法头文件
#include
#include
#include
using namespace std;
//比较两个单词的长度大小
bool isShorter(const string &s1,const string &s2){
	return s1.size()=6;
}

int main(){

	vector words;
	string next_word;
	while(cin >> next_word){
		words.push_back(next_word);
	}

	//排序
	sort(words.begin(),words.end());
	//删除相邻的重复单词，把该重复的单词移动到最后
	vector::iterator end_unique=unique(words.begin(),words.end());
	//真正的删除容器的元素
	words.erase(end_unique,words.end());
	//根据单词长度排序
	stable_sort(words.begin(),words.end(),isShorter);
	//判断单词长度是否大于6
	vector::size_type wc=count_if(words.begin(),words.end(),GT6);
	cout<