1、概述
泛型算法本身不会执行容器操作，它们只会运行在迭代器之上，执行迭代器的操作
结论：算法永远不会改变底层容器的大小，算法可能改变容器中保存的元素的值或者移动元素，但永远不会直接添加或者删除元素。
！除了少数以外，标准库算法都对一个范围内的元素进行操作，我们将此元素范围称为“输入范围”。接受输入范围的算法总能使用前两个参数
来指定范围，两个参数分别为首元素和尾元素的下一个迭代器。
算法如何工作（以find为例）：
1）、访问序列中的首元素
2）、比较元素与我们要查找的值
3）、如果此元素与我们要查找的值匹配，find返回标识此元素的值
4）、否则，find前进道下一个元素，重复执行步骤2和3
5）、如果达到序列尾，find停止工作
6）、如果find达到序列末尾，应返回一个指向元素未找的的值，此值和步骤3的值具有相容的类型。
迭代器算法不依赖于容器，但算法依赖于元素类型的操作
#include <numeric>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
//accumulate(egin, end, initial_value);
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
cout << accumulate(ivec.begin(), ivec.end(), 0) << endl;
//字符串必须类型相同，如果accumulate中s换为""就会出错，""是const char*类型的，类型不一致
//所以序列中的元素必须和第三个参数相匹配，或者能转换成第三个参数。
string s = "";
vector<string>ivecs = {"hello", "world", "haha"};
cout << accumulate(ivecs.begin(), ivecs.end(), s) << endl;
}2、初识泛型算法
只读算法：
acculturate函数接受三个参数，前两个指出了需要求和的元素的范围，第三个参数是和的初值。假定vec是一个整数序列
int sum = accumulate(vi.begin(), vi.end(), 0);//将sum设置为vec中元素的和，和的初值被设置为0//接受三个迭代器，前两个和以前一样，表示第一个序列中的元素范围，第三个表示第二个序列的收元素
equal(vi.cbegin(),vi.cend(),v2.cbegin());
fill(vi.begin(), vi.end(), 0);//将每个元素赋值为0
fill(vi.begin(),vi.begin()+vi.size()/2,10);//将每个元素赋值为10算法不检查写操作
vector<int> vec1,vec2;//空vector
//使用vector，赋予它不同的值
fill_n(vec1.begin(),vec1.size(),0);//将所有元素重置为0
//错误，修改vec2中所有元素，不存在
fill_n(vec2.begin(),10,0);通常情况下，当我们通过一个迭代器向容器元素赋值时，值被赋予迭代器指向的元素，而当我们通过一个插入迭代器赋值时，一个与赋值号右侧值相等的元素被添加到容器中。
vector<int> vec;//空向量
auto it = back_insert(vec);//通过it赋值会将元素添加到vec中
×it=42;//vec现在有一个元素，值为42
vector<int> vec3;
//正确，back_inserter创建一个插入迭代器，可以用来向vec添加元素
fill_n(back_insert(vec),10,0);//添加10个0到ve拷贝算法：
传递给copy的目的序列至少要包含与输入序列一样多的元素
int a1[]={0,1,2,3,4,5,6,7,8,9};
int a2[sizeof(a1)/sizeof(*a1)];//sizeof(a1)为10*4
//ret指向拷贝到a2的尾元素之后的位置
auto ret=copy(begin(a1),end(a1),a2);//把a1的内容拷贝给a2
replace(ilist.begin(),ilist.end(),0,42);//将所有值为0的元素都改为42
replace_copy(ilist.begin(),ilist.end(),back_insert(ivec),0,42);//ilist并未改变，ivec包含ilist的一份拷贝，不过ilist中原来为0的数都变为42
重排容器元素的算法
void elimDups(vector<string> &words){
//按照字典排序，以便查找重复单词
sort(words.begin(),words.end());
//unique重排输入范围,使得每个单词只出现一次
//排列在范围的前部，返回指向不重复区域的之后一个位置的迭代器
auto end_unique=unique(words.begin(),words.end());
//,unique并没有删除重复元素，只是被不重复的元素覆盖了 使用向量操作erase删除重复单词
words.erase(end_unique,words.end());
}
3、定制操作
向算法传递函数
谓词是一个可调用的表达式
bool isShorter(const string &s1,const string &s2){
return s1.size()<s2.size();
}
//按照长度由短至长排序
sort(words,begin(),words.end(),isShorter);排序算法
为了保持相同长度的单词按照字典序列排序，可以使用stable_sort算法，这种算法维持相等元素的原有顺序
elimDups(words);//将words按照字典重排，并消除重复单词
//按照长度重新排序，长度相同的单词维持字典序
stable_sort(words.begin(),words.ed(),isShorter);
for(const auto &s:words)//无须拷贝字符串
cout<<s<<" ";打印每个元素，以空格分割
cout<<endl;
lambda表达式
elimDups(words);//将words按照字典重排，并消除重复单词
//按照长度重新排序，长度相同的单词维持字典序
stable_sort(words.begin(),words.ed(),isShorter);
for(const auto &s:words)//无须拷贝字符串
cout<<s<<" ";打印每个元素，以空格分割
cout<<endl;
[capture list] (parameter list) ->list retur type {functio body}
其中，capture list是一个lambda所在函数中定义的局部变量的列表（通常为空），lambda必须使用尾置返回
auto f = []{retur 42;};
cout<<f()<<endl向lambda传递参数
[](const string &a,const string &b){
return a.size()<b.size();
}
stable_sort(words.begin(),words.end(),
[](const string &a,const string &b){
return a.size()<b.size();
})
lambda不能由默认参数，一个lambda调用的实参数目永远与形参数目相等，空捕获列表表明次lambda不使用它所在函数中的任何局部变量。
使用捕获列表：lambda通过将局部变量包含在其捕获列表中来指出将会使用这些变量。捕获者列表指引lambda在其内部包含访问局部变量所需要的信息。
在本例中，lambda捕获sz，并只有单一的string参数，此函数体会将string的大小与捕获的sz值进行比较
void biggies(vector<string> &words,vector<strig>::size_type sz){
elimDups(words);//将words按照字典排序，删除重复单词
//按照长度排序，长度相同的单词维持字典序
//stable_sort(words,begin(),words.end(),isShorter);
stable_sort(words.begin(),words.ed(),
[](const string &a,const &b){
return a.size()<b.size();
});
//获取一个迭代器，指向第一个满足size()>=sz的元素
auto wc = find_if(words.begin(),words.ed(),
[sz](const string &a){
return a.size()>=sz;
});
//计算满足size>=sz的元素的数目
auto count<<words.end()-wc;
cout<<count<<" "<<make_plural(count,"word","s")
<<"of length" <<sz<<" or longer"<<endl;
//打印长度大于等于给定值的单词，每个单词后面接一个空格
for_each(wc,words.ends,[](const string &s){cout<<s<<" ";});
cout<<endl;
}
lambda捕获和返回值
值捕获 采用值捕获的前提是变量可以拷贝，与参数不同的是北部获得变量的值是在lambda创建时的拷贝，而不是调用时拷贝。
void fcn1(){
size_t v1= 42;//局部变量
//将v1拷贝到名为f的可调用对象
auto f = [v1]{return v1;}
v1= 0;
auto j = f();//j为42，f保存了我们创建它时的拷贝
}
由于捕获的变量的值实在lambda创建时拷贝，随后的修改不会影响到lambda内对应的值。
引用捕获
void fcn2(){
size_t v1= 42;
//对象f2包含v1的引用
auto f2 = [&v1]{return v1;};
v1= 0;
auto j = f2();//j为0 ，f2保存v1的引用，而非拷贝
}
如果我们采用引用方式捕获一个变量，就必须保证被引用的对象在lambda执行的时候是存在的
void biggies(vector<string> &words,vector<string>::size_type sz,ostream &os = count,char c=' '){
//与之前例子一样的重排words的代码
//打印count的语句改为打印到os
for_each(words.begin(),words.end(),[&os,c](const string &s){os<<s<<c;});
}
我们不能拷贝osstream，因此捕获os的唯一方法就是捕获其引用。
隐式捕获：[&] 引用 [=] 值
//sz为隐式捕获，值捕获
wc=find_if(words.begin(),words.end(),[=](const string &s)
{
return s.size() >= sz;
});如果混合使用引用 值捕获
void biggies(vector<string> &words,vector<string>::size_type sz,ostream &os = cout,char c = ' '){
//os隐式捕获、引用捕获方式，c显式捕获，值捕获
for_each(words.begin(),words.end(),
[&,c](const string &s){os <<s<<c;});
//os显示捕获，引用捕获，c为隐式捕获，值捕获
for_each(words.begin(),words.end(),
[=,&os](const string &s){os<<s<<c;});
}注意，混合捕获方式 第一个必须是&或者=。
可变lambda：如果希望被捕获变量的值，就必须在参数列表表首前加关键字mutable。
void fc3(){
size_t v1= 42;
//f可以改变它所捕获的变量的值
auto f = [v1]()mutable{return ++v1;};
v1=0;
auto j = f();//j为43
}
void fcn4(){
size_t v1 = 42;
//v1是一个非const的变量的引用
//可以通过f2中的引用来改变它
auto f2 = [&v1]{return ++v1};
v1=0;
auto j = f2();//j为1
}
当我们需要为lambda定义返回类型时，必须使用尾置类型
transform(v1.begin(),v1.end(),v1,begin(),
[](int i)->int{
if(i<0) return -i;else return i;
});
参数绑定
标准库bind函数：
调用bind的一般形式为：
auto newCallabel = bind(callable,arg_list);
//check6是一个可调用对象，接受一个string类型的参数
//并用此string和值6来调用check_size
auto check6=bind(check_size,_1,6);
//g是一个有俩个参数的可调用对象
auto g = bind(f,a,b,_2,c_1);
g(_1,_2);
当我们调用g时，其第一个参数将被传递给f作为最后一个参数，第二个参数传递给f作为第三个参数
用bind重排参数顺序
//按单词长度由短至长排序
sort(words.begin(),words.end(),isShorter);
//按单词长度由长至短排序
sort(words.begin(),words.end(),bind(isShorter,_2,_1));
//os是一个局部变量，引用一个输出流
//c是一个局部变量，类型为char
for_each(words.begin(),words.end(),[&os,c](const string &s){
os<<s<<c;
});
//功能同上
ostream &print(ostream &os,const string &s,char c){
return os <<s<<c;
}不能用bind拷贝其参数，因为不能拷贝ostream，如果希望给bind，使用ref
for_each(words.begin(),words.ed(),bind(print,ref(os),_1,' '));
函数ref返回一个对象，包含给定的引用，此对象使可以拷贝的。
4、再探迭代器
插入迭代器有三种：
back_inserter :创建一个push_back迭代器
frot_inserter:创建一个push_front的迭代器
inserter ：创建一个使用insert的迭代器
当调用inserter（c，iter）时候，我们得到一个迭代器，接下来使用它时，会将元素插入倒iter原来所指元素之前的位置，即，如果it是由inserter生成的迭代器，则下面赋值语句相等：
*it=val;
//其效果与下面代码一样
it = c.insert(it,val);//it指向新加入的元素
++it;
frot_inserter:与上一个不同，元素总是插入到第一个元素之前
list<int> lst={1,2,3,4};
list<int> lst2,lst3;//空
//拷贝完成后，lst2包含4 3 2 1
copy(lst.cbegin(),lst.cend(),front_insert(lst2));
//拷贝完成后，lst3包含1 2 3 4
copy(lst.cbegin(),lst.cend(),inserter(lst3,lst3.begin()));
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<int> in_iter(cin);//从cin中读取int
istream_iterator<int> eof;//istream尾后迭代器
while(in_iter != eof)
//后置递增预算读取流，返回迭代器的旧值
//解引用迭代器，获取从流读取的前一个值
vec.push_back(*in_iter++);
//计算标准输入读取的值的和
istream_iterator<int> in(cin),eof;
cout<<accumulate(in,eof,0)<<endl;
ostream_iterator<int> out_iter(cout," ");
for(auto e:vec)
*out_iter++=e;//赋值语句实际上将元素写到cout
cout<<endl;
//等同下面语句
for(auto e:vec);
cout<<ednl;
5、泛型算法结构
6、特定容器算法
//调用erase删除掉给定值相等或另一元谓词为真的每个元素
lst.remove(val) ；
lst.remove_if(pred);
lst.reverse();//翻转lst
lst.sort();//使用<或给定的比较操作排序元素
lst.sort(comp);
lst.unique();//调用erase删除同一个值的连续拷贝
lst.unique(pred);
502
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
