generic algorithm
一， 概述
1，标准库没有为每种容器类型都定义是吸纳某些特定操作的成员函数，而是定义了一组泛型算法；自定义的容器类型只要与标准库兼容，也可以使用这些算法。
2，每个泛型算法的实现独立于容器，且不依赖于容器存储的元素类型；
3，算法往往需要通过两个迭代器遍历一段元素来实现其功能；
a) 迭代器支持自增操作符，相等和不等操作符；
b) 第二个迭代器为超出末端迭代器，第一个迭代器必须能够通过自增到达第二个迭代器；
4，泛型算法本身不执行容器操作：
a) 基于迭代器及其操作实现，不急于容器的操作；
b) 即算法从不修改基础容器的大小，即可能会改变存储在容器中的值，可能会移动元素，但是不会直接添加或者删除元素。
c) 如果需要实现更多的操作，可以使用插入器（也是一种迭代器），但是算法本身不这么做；
5，泛型算法需包含<algorithm>头文件，泛化的算术算法必须包含<numeric>头文件。
二， 初窥算法
1，只读算法：例如find，accumulate，find_first_of等；
int sum = accumulate(vec.begin(), vec.end, 42); //第三个参数为起累加始值
a) accumulate算法对容器一无所知：
i. 必须传递一个起始值告知起始值类型；
ii. 容器内的元素类型必须和起始值类型匹配，或者可以转换；
b) 标记迭代器范围的两个实参类型必须精确匹配：
i. 第一个迭代器必须能够通过不断自增到达第二个迭代器；
ii. 如果算法带有两队迭代器参数，则每对迭代器中的实参类型必须精确匹配，但不要求两对之间的类型匹配，即元素可以存储在不同类型的序列中，只要两个元素的序列可以比较即可。
2，写容器元素的算法：小心！必须确保算法所写的序列至少足以存储要写入的元素。
a) 三种类型的写入算法：
i. 直接将数据写入输入序列；
ii. 带有额外的迭代器参数指定写入目标；
iii. 将指定数目的元素写入某序列：这种算法不检查目标的大小是否足以存储要写入的元素，容易造成灾难性后果！
b) 确保算法有足够的元素存储输出数据的一种方法是使用插入迭代器，
i. 插入迭代器是可以给基础容器添加元素的迭代器；
ii. 需要包含<iterator>头文件；
iii. 是一种迭代器适配器，使用一个对象作为实参，并生成一个适应其实参行为的新对象；
iv. 如back_inserter生成一个绑定在该容器上的插入迭代器，在试图通过该迭代器给元素赋值时，赋值运算符将调用push_back添加一个具有指定值的元素。
c) 写入到目标迭代器的算法：
i. 该算法向目标迭代器写入未知个数的元素，如copy算法：
vector<int> ivec;
copy( ilst.begin(), ilst.end(), back_inserter(ivec));
d) 各个算法的_copy版本：有的操作在对序列做操作后如果不想改变原序列，就会定义一个复制版本，将新生成的序列存储到目标序列中；如：replace和replace_copy。
replace( ilst.begin(), ilst.end(), 0, 42);
replace_copy( ilst.begin(), ilst.end(), back_inserter(ivec), 0, 42 );
3，对容器元素重新排序的算法
a) 通过一个例子说明：统计一段话中使用了多少个由6个或以上字母组成的单词，同一单词不重复计数。实现步骤如下：
i. 去掉所有重复的单词；
ii. 按单词的长度排序；
iii. 统计长度等于或者超过6个字符的单词数；
iv. 程序如下：
bool isShorter(const string & s1, const string & s2 ){
return s1.size() < s2.size(); //长度比较函数
}
bool GT6 (const string & s ){ return s.size() >= 6; } //判断长度函数
int main(){ //主函数
vector<string> words;
string next_word;
while (cin >> next_word){ word.push_back(next_word); }
//对数组排序
sort ( words.begin(), words.end() );
//删除重复的元素
vector<string>::iterator end_unique =
unique(words.begin(), words.end() );
words.erase(end_unique, words.end() );
//
stable_sort( words.begin(), words.end(), isShorter ); //需要一个谓词
vector<string>::size_type wc =
count_if (words.begin(), words.end(), GT6 ); //需要一个谓词
cout<< … …
return 0;
}
b) unique的使用
i. “删除”相邻的重复元素，重新排列输入范围内的元素，返回一个迭代器，表示无重复的值范围的结束；
ii. 但此时words的大小并没有改变！只是顺序变了，除了被新排序的元素覆盖的元素外，剩下的元素还在；算法不能删除元素！
iii. 要用算法返回的迭代器配合容器操作erase来删除多余的元素；
c) 使用容器操作删除元素
d) 定义需要的谓词
i. 一些算法的某个重载版本使用时可能需要一个配套的实用函数，即谓词，如count_if和stable_sort；
ii. 传递给算法的谓词的性参数目是有要求的，如count_if的谓词只能接受1个形参，而stable_sort的谓词则需要接受2个形参；
三， 再谈迭代器
1，包含<iterator>头文件！
2， 插入迭代器
a) 插入器是一种迭代器适配器，带有一个容器参数，并生成一个迭代器，用于在指定容器中插入元素；
b) back_inserter使用push_back，只有一个形参；
vector<int> ivec;
copy( ilst.begin(), ilst.end(), back_inserter(ivec));
c) front_inserter使用push_front，只有一个形参；
i. 只有当容器提供push_front和push_back操作时，才能使用上述迭代器适配器，在vector上就不能使用push_f；
d) inserter将产生在指定位置时先插入的迭代器
i. 有两个实参：所关联的容器和只是其实插入位置的迭代器；
ii. 总是在它的迭代器实参所标明的位置前面插入新元素；
iii. 与front_inserter的区别：front_inserter始终在首元素之前插入，而即使给inserter传递了ivec.begin()作为迭代器实参，也不能实现front_inserter的操作，因为在插入第一个元素后，它就不再是首元素了；
即用front_inserter插入将导致元素反向排列，而用inserter则不会；
3， iostream迭代器
| iostream迭代器的构造函数 | |
| istream_iterator<T> in(strm); | 创建从输入流strm中读取T类型对象的istream_iterator对象 |
| istream_iterator<T> in; | istream_iterator的超出末端迭代器 |
| ostream_iterator<T> in(strm); | 创建将T类型的对象写到输出流strm的ostream_iterator对象 |
| ostream_iterator<T> in(strm, delim); | 同上，在写入过程中将delim作为元素的间隔符。delim是以空字符结束的字符数组。 |
a) 流迭代器的定义和创建
i. 流迭代器都是类模板：任何已定义>>操作符操作符的类型都可以定义istream_iterator，任何已定义<<操作符的类型都可以定义ostream_iterator；
ii. 创建流迭代器时，必须指定迭代器所读写的对象类型；
iii. 创建ostream_iterator必须和特定的流绑定在一起；ostream_iterator不提供超出末端迭代器。
iv. 创建istream_iterator时，可以直接绑定到一个流上，也可以创建时不提供实参，则迭代器指向超出末端位置。
| istream_iterator的操作 | |
| it1 == it2 | 比较是否相等，迭代器读取的必须是相同的类型。 |
| it1 != it2 | 如果两个迭代器都是end值，则相等； 对于两个都不指向end的迭代器，如果他们使用同一个输入流构造，则他们也相等； |
| *it | 返回流中读取的值 |
| it->mem | 返回从流中读取的对象的mem成员 |
| ++it | 通过使用元素类型提供的>>操作符从输入流中读取下一个元素值，使迭代器向前移动； 前缀版本返回移动后对迭代器的引用，后缀版本返回原值。 |
| it++ | |
b) istream_iterator对象上的操作
i. 用法1：
istream_iterator<int> in_iter(cin);
istream_iterator<int> eof;
while ( in_iter != eof) vec.push_back(*in_iter++);
eof迭代器定义为空的istream_iterator对象，用作结束迭代器。绑在流上的迭代器遇到文件结束或者某个错误时，将等于结束迭代器的值；
ii. 用法2：
istream_iterator<int> in_iter(cin);
istream_iterator<int> eof;
vector<int> vec( in_iter, eof );
用一对标记元素范围的迭代器构造vec对象。效果是读cin，知道到达文件结束或者输入的不是int型数值为止，读的元素用于构造vec对象。
c) ostream_iterator对象和ostream_iterator对象的使用
i. 用法1：
ostream_iterator<string> out_iter(cout, “/n”);
istream_iterator<string> in_iter(cin), eof;
while ( in_iter != eof ) *out_iter++ = *in_iter++;
作用：读cin，并将读入的值写到cout中不同的行中；
d) 再累类型上使用istream_iterator
i. 提供了>>操作符的任何类型都可以创建istream_iterator对象。
ii. 例子如下：
istream_iterator<Sales_item> item_iter(cin), eof;
Sales_item sum;
sum = *item_iter++;
while (item_iter) {
if (item_iter->same_isbn(sum)) sum = sum + *item_iter;
else { cout << sum << endl; sum = *item_iter; }
++item_iter;
}
cout << sum << endl;
e) 迭代器的限制：
i. 不能从ostream_iterator中读入，也不能写到istream_iterator对象中；
ii. 一段给ostream_iterator赋值，就不能修改了，每个不同值都只能正好输出一次；
iii. ostream_iterator没有->操作符。
f) 与算法一起使用流迭代器
i. 例子1：从输入读取一些数，再不重复的输出到标准输出
istream_iterator<int> cin_it(cin);
istream_iterator<int> end_of_stream;
vector<int> vec( cin_it, end_of_stream );
sort ( vec.begin(), vec.end() );
ostream_iterator<int> output ( cout, “ “ );
unique_copy ( vec.begin(), vec.end(), output );
4， 反向迭代器reverse_iterator
a) 反向迭代器是一种反向遍历容器的迭代器：
i. ++运算符将访问前一个元素，反之亦然；
ii. 容器定了begin和end成员，也定义了rbegin和rend成员，后者就是反向迭代器；
b) 例子1：逆序输出元素：
vector<int>::reverse_iterator r_iter;
for (r_iter = vec.rbegin(); r_iter != vec.rend(); ++r_iter )
cout << *r_iter << endl;
c) 例子2：将序排列vector，只需向sort传递一对反向迭代器：
sort( vec.rbegin(), vec.rend() );
d) 反向迭代器需要使用自减操作符，所以流迭代器不能创建反向迭代器，因为流不能被反向遍历；
e) 反向迭代器与其他迭代器之间的关系：
如图显示的对象直观的结束了普通迭代器与反向迭代器之间的关系：
i. 设计普通迭代器与反向迭代器之间的关系是为了适应左闭合范围，以使[ line.rbegin(), rcomma )和( rcomma.base(), line.end() ]标记的是line中的相同元素。
ii. 程序如下（假设有一个名为line的string对象，存储以逗号分隔的单词列表，我们希望输出line中的第一个单词）：
string::iterator comma = find( line.begin(), line.end(), ‘,’ );
cout << string(line.begin(), comma) << endl;
//输出：FIRST
string::reverse_iterator rcomma = find( line.rbegin(), line.rend(), ‘,’ );
cout << string( line.rbegin(), rcomma ) << endl;
//输出：TSAL 这是错误的！原因从上图可以看出，正确的方法如下：
cout << string( rcomma.base(), line.end() ) << endl;
5， const迭代器
a) 如果我们不希望使用迭代器来修改容器中的元素，那么可以定义为const_iterator类型；
b) 但是，用于算法中表示范围的两个迭代器必须具有完全一样的类型，所以，如果另一个迭代器不是const类型，那么即使不希望改变元素，也不能定义成const类型；
c) 类似lst.begin()，lis.end()返回的迭代器的类型依赖于所指向的容器存放的元素的类型，存放的是const对象，则返回const_iterator类型的迭代器，反之亦然。
6， 五种迭代器
| 迭代器种类（按算法要求的迭代器操作分类） | |
| 输入迭代器 | 读，不能写；只支持自增运算 |
| 输出迭代器 | 写，不能读；只支持自增运算 |
| 前向迭代器 | 读和写；只支持自增运算 |
| 双向迭代器 | 读和写；支持自增和自减运算 |
| 随机访问迭代器 | 读和写；支持完整的迭代器算术运算 |
a) 输入迭代器
i. 可读，不保证能写；
ii. 支持==和!=操作符，自增操作符（++），解引用（*）操作符，箭头操作符（->）（对迭代器进行解应用来获取所关联的对象的成员）。
iii. 一旦自增了，就无法检查之前的元素；
iv. istream_iterator即为此类型，find和accumulate算法；
b) 输出迭代器
i. 可写，不保证可读；
ii. 支持++操作符；
iii. 支持解引用（*），此操作符只能出现在赋值运算的左操作数上，用来对该迭代器所指向的元素做写入操作；
iv. 可以要求每个迭代器的值必须正好写入一次；？？
v. 输出迭代器一般用作算法的第三个实参，用于标注开始写入的位置；
vi. copy算法；ostream_iterator为输出迭代器。
c) 前向迭代器
i. 只能以一个方向遍历序列；
ii. 支持输入迭代器和输出迭代器的所有操作，支持对同一个元素的多次读写；
iii. 需要复制向前迭代器来记录序列中的一个位置，以便返回此处；
iv. replace算法。
d) 双向迭代器
i. 从两个方向读写容器；
ii. 支持前向迭代器的所有操作，还有前置和后置的--操作；
iii. 所有标准库容器提供的迭代器都至少达到双向迭代器的要求；
iv. reverse算法；
v. map，set，list提供双向迭代器。
e) 随机访问迭代器
i. 访问容器任意位置；
ii. 支持关系操作符，与整数值之间的算术运算操作符，两个迭代器之间的减法操作符（返回距离），下标操作符（iter[n]相当于*(iter+n)）;
iii. vector，deque，string和内置数组元素的指针都是随机访问迭代器；
iv. sort算法。
f) 除了输出迭代器：在需要低级类别迭代器的地方，可以使用任意一种更高级的迭代器。
注：向算法传递无效的迭代器类别所引起的错误，无法保证会在编译时被捕捉到！
四， 泛型算法的结构
1，算法的形参模式：算法最基本的性质是需要使用的迭代器总类。
a) alg( beg, end, other parms );
b) alg( beg, end, dest, other parms );
i. 算法假定无论需要写入多少元素都是安全的；
ii. 调用算法是，必须确保输出容器有足够大的容量存储输出数据，这正是通常要使用插入迭代器或者ostream_iterator来调用这些算法的原因。
c) alg( beg, end, beg2, otherparms );
i. 算法假定以beg2开始的范围至少与beg和end指定的范围一样大。
d) alg( beg, end, beg2, end2, otherparms );
2，算法的命名规范：算法使用一组相同的命名和重载函数的规范。
a) 两种基本模式：测试输入范围内元素的算法，对输入范围内元素重新排序的算法。
b) 测试输入的元素的算法：区别带有一个值或一个为此函数参数的算法版本
i. 通常要用到标准关系操作符：==和<;
ii. 其中大部分算法提供第二个版本，允许程序员提供谓词取代操作符；
iii. 如果算法的两种版本性参数不同，则通过重载函数实现第二个版本：
sort (beg, end ); //
sort ( beg, end, comp ); //通过重载实现，comp为谓词
iv. 如果算法的两种版本形参数相同，则通过增加名字后缀_if来区别：
find ( beg, end, val );
find_if ( beg, end, pred ); //通过名字后缀来区分，pred为谓词
c) 对输入元素重新排序的算法：区别是否实现复制的算法版本
i. 无论算法是否检查它的元素值，都可能重新排列输入范围内的元素；
ii. 默认情况下，算法将重新排列后的元素写回其输入的范围；
iii. 如果要将排列后的元素写到输出目标，则用名字后缀_copy加以区分：
reverse ( beg, end );
reverse_copy ( beg, end, dest);
五， 容器特有的算法
| list容器的特有操作 | |
| lst.merge (lst2) | 将lst2的元素合并到lst中； 两个list对象都必须排序； 合并后来lst2为空，返回void类型。 |
| lst.merge (lst2, comp) | |
| lst.remove ( val ) | 调用lst.erase删除所有等于指定值或使指定的为此函数返回非零值的元素； 返回void类型。 |
| lst.remove_if ( unaryPred ) | |
| lst.reverse () | 反向排列 |
| lst.sort () | 排序 |
| lst.splice ( iter, lst2 ) | 将lst2中的元素一道lst中iter指向的元素前，并删除lst2中移除的元素； 第一个版本：移动所有元素，lst2和lst不能是同一个list对象； 第二个版本：移动iter2指向的元素，必须是lst2中的元素，lst2和lst可以是同一个list对象； 第三个版本：移动范围内的元素，必须是一个有效的范围，可以是lst中的元素，但iter指向的元素不能再该范围内； |
| lst.splice ( iter, lst2, iter2 ) | |
| lst.splice ( iter, beg, end ) | |
| lst.unique () | 调用erase删除同一个值的连续副本 |
| lst.unique ( binaryPred ) | |
1401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
