1、泛型算法本身不会执行容器的操作，只会运行于迭代器之上，执行迭代器的操作。算法永远不会改变底层容器的大小。
2、只读算法：一些算法只会读取其输入范围内的元素，从不改变元素。 对于只读算法，最好使用次cbegin()和cend()。
find：接受三个参数，前两个指出查找的元素的范围，第三个参数是要查找的元素。返回指向要查找元素的迭代器，若没找到指定元素，返回尾后迭代器。
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
vector<int> vec = { 27, 210, 12, 47, 109, 83 };
int val = 83;
auto result = find(vec.cbegin(), vec.cend(), val);
cout << *result << endl; //输出83
system("pause");
return 0;
}
accumulate：接受三个参数，前两个指出需要求和的元素的范围，第三个参数是和的初值。返回求和的结果。
#include<iostream>
#include<algorithm>
#include<numeric>
#include<vector>
#include<string>
using namespace std;
int main(){
vector<int> vec{ 1, 2, 3, 4 };
int val = 0;
auto result = accumulate(vec.cbegin(), vec.cend(), val);
cout << result << endl; //输出10
//string定义了+运算符，能用accumulate函数将string元素连接起来
vector<string> svec{ "aaa", "bbb", "vvv" };
auto sresult = accumulate(svec.cbegin(), svec.cend(), string(""));
cout << sresult << endl; //输出aaabbbvvv
system("pause");
return 0;
}
equal：接受三个参数，前两个指出第一个序列中的元素范围，第三个参数表示指向第二个序列首元素的迭代器。判断两个序列是否保存相同的值。假定第二个序列至少与第一个序列一样长。
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
using namespace std;
int main(){
vector<int> vec{ 1, 2, 3, 4 };
list<int> li{ 1, 2, 3, 4 };
cout << equal(vec.begin(), vec.end(), li.begin()) << endl; //输出1
cout << equal(vec.begin() + 1, vec.end(), li.begin()) << endl; //输出0
system("pause");
return 0;
}
3、 写容器元素算法：必须确保序列原大小不小于要求写入的元素数目。
fill：接受三个参数，前两个指出序列中的元素范围，第三个参数表示将这个值赋予序列中的每个元素。
fill_n：接受一个单迭代器、一个计数值和一个值。将给定值赋予迭代器指向的元素开始的指定个元素。
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
vector<int> vec{ 1, 2, 3, 4 };
fill(vec.begin(), vec.begin() + vec.size() / 2, 0);
for (const auto& c : vec)
cout << c << " ";
cout << endl; //输出0 0 3 4
//向目的位置迭代器写入数据的算法假定目的位置足够大，能容纳要写入的元素
fill_n(vec.begin(), 3, 1);
for (const auto& c : vec)
cout << c << " ";
cout << endl; //输出1 1 1 4
system("pause");
return 0;
}
back_inserter：接受一个指向容器的引用，返回一个与该容器绑定的插入迭代器。
#include<iostream>
#include<algorithm>
#include<vector>
#include<iterator>
using namespace std;
int main(){
vector<int> vec;
fill_n(back_inserter(vec),5,0);
for(const auto& c:vec)
cout<<c<<" ";
cout<<endl; //输出0 0 0 0 0
system("pause");
return 0;
}
4、 拷贝算法
copy：接受三个迭代器，前两个表示输入范围，第三个表示目的序列的起始位置。把输入范围中的元素拷贝到目的序列中。
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int ia1[]={1,2,3,4};
int ia2[sizeof(ia1)/sizeof(*ia1)];
auto ret=copy(begin(ia1),end(ia1),ia2);//ret指向拷贝到ia2的尾元素之后的位置
for(const auto& i:ia2)
cout<<i<<" ";
cout<<endl; //输出1 2 3 4
system("pause");
return 0;
}
5、 重排容器元素算法
sort：接受两个迭代器，表示排序的元素范围
unique：将相邻的重复项“消除”，并返回一个指向不重复值范围末尾的迭代器。此位置之后的元素仍存在，但不知道值是什么。
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<vector>
using namespace std;
int main(){
string str="the quuick red fox jumps over the slow red turtle";
stringstream ss(str);
string word;
vector<string> vec;
while(ss>>word)
vec.push_back(word);
sort(vec.begin(),vec.end());
for(const auto& i:vec)
cout<<i<<" ";
cout<<endl; //输出fox jumps over quuick red slow the the turtle
auto end_unique=unique(vec.begin(),vec.end());
vec.erase(end_unique,vec.end());
for(const auto& i:vec)
cout<<i<<" ";
cout<<endl; //输出fox jumps over quuick red slow the turtle
system("pause");
return 0;
}
6、谓词是一个可调用的表达式，返回结果是能用作条件的值。谓词分一元谓词和二元谓词。
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<vector>
using namespace std;
//二元谓词，比较函数，按长度排序单词
bool isShorter(const string& s1,const string& s2){
return s1.size()<s2.size();
}
int main(){
string str="the quuick red fox jumps over the slow red turtle";
stringstream ss(str);
string word;
vector<string> vec;
while(ss>>word)
vec.push_back(word);
vector<string> vec2(vec);
sort(vec.begin(),vec.end(),isShorter);//按长度由短至长排序
for(const auto& i:vec)
cout<<i<<" ";
cout<<endl; //输出the red fox the red over slow jumps quick turtle
system("pause");
return 0;
}7、lambda表达式具有如下形式
[capture list](parameter list) -> return type { function body }
capture list(捕获列表)是一个lambda所在函数中定义的局部变量的列表（通常为空）。return type、parameter list和function body分别表示返回类型(必须是尾置返回类型)、参数列表和函数体。可以忽略参数列表和返回类型，但必须永远包含捕获列表和函数体。
与上面isShorter函数完成相同功能的lambda：
[](const string& s1,const string& s2){ return s1.size()<s2.size(); }
lambda值捕获
void fun1(){
size_t v1=42;
auto f=[v1]{ return v1; };
v1=0;
auto j=f(); //j为42，f保存了我们创建它时v1的拷贝
}lambda引用捕获void fun2(){
size_t v1=42;
auto f=[&v1]{ return v1; };
v1=0;
auto j=f(); //j为0，f保存了v1的引用
}lambda隐式捕获:&采用引用捕获方式，=采用值捕获方式[=](const string& s1,const string& s2){ return s1.size()>=size; }可变lambda：在参数列表首加上关键字mutable，改变被捕获变量的值void fun3(){
size_t v1=42;
auto f=[v1] () mutable { return v1; };
v1=0;
auto j=f(); //j为43
}8、 参数绑定
bind函数在头文件functional中，调用bind函数的一般形式为：
auto newCallable=bind(callable,arg_list);
newCallable本身是一个可调用的对象，arg_list是一个逗号分割的参数列表，对应给定callable的参数。
arg_list可能包含形如_n的名字，n是一个整数，这些参数是占位符，表示了newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象中参数的位置。_n定义在一个名为placeholders的命名空间中。
bind拷贝其参数，当希望传递给bind一个对象又不拷贝它，必须使用ref函数。
#include<iostream>
#include<functional>
using namespace std;
using namespace std::placeholders;
int add(int a,int b,int c,int d){
return a+b+c+d;
}
int main(){
int a=1,c=2;
auto g=bind(add,a,_2,c,_1);
cout<<g(3,4)<<endl; //调用add(1,4,2,3);
system("pause");
return 0;
}
9、 插入迭代器
back_inserter 创建一个使用push_back的迭代器 。
front_inserter 创建一个使用push_front的迭代器。
inserter创建一个使用insert的迭代器，此函数接受两个参数，这个参数必须是指向给定容器的迭代器。元素将被插入到给定迭代器所表示的元素之前。
#include<iostream>
#include<list>
#include<iterator>
using namespace std;
int main(){
list<int> lst{ 1, 2, 3, 4 };
list<int> lst2, lst3, lst4;
copy(lst.cbegin(), lst.cend(), back_inserter(lst2));
for (const auto& l : lst2)
cout << l << " ";
cout << endl; //输出1 2 3 4
copy(lst.cbegin(), lst.cend(), front_inserter(lst3));
for (const auto& l : lst3)
cout << l << " ";
cout << endl; //输出4 3 2 1
copy(lst.cbegin(), lst.cend(), inserter(lst4, lst4.begin()));
for (const auto& l : lst4)
cout << l << " ";
cout << endl; //输出1 2 3 4
system("pause");
return 0;
}
10、iostream迭代器
istream_iterator迭代器：读取输入流
ostream_iterator迭代器：向输出流写数据
#include<iostream>
#include<list>
#include<iterator>
using namespace std;
int main(){
list<int> lst;
istream_iterator<int> in(cin),eof;
while(in!=eof)
lst.push_back(*in++);//解引用迭代器，获得从流读取的前一个值
ostream_iterator<int> out(cout," ");
for(const auto& l:lst)
*out++=l; //将元素写到cout
cout<<endl;
system("pause");
return 0;
}
11、反向迭代器
反向迭代器就是在容器中从尾元素向首元素反向移动的迭代器。对于反向迭代器，++iter会移动到前一个元素,--iter会移动到下一个元素。除了forward_list之外，其他的容器都定义了反向迭代器。
下图显示了一个名为vec的vector上的4种迭代器：
#include<iostream>
#include<string>
#include<iterator>
#include<algorithm>
using namespace std;
int main(){
string str="FIRST,MIDDLE,LAST";
auto comma=find(str.cbegin(),str.cend(),',');
cout<<string(str.cbegin(),comma)<<endl; //输出FIRST
auto rcomma=find(str.crbegin(),str.crend(),',');
cout<<string(rcomma.base(),str.cend())<<endl;//输出LAST
system("pause");
return 0;
}
用图表示上面各个迭代器：
12、迭代器类别
输入迭代器：只读，不写，单遍扫描，只能递增
输出迭代器：只写，不读，单遍扫描，只能递增
前向迭代器：可以读写，多遍扫描，只能向前
双向迭代器：可以读写，多遍扫描，可以递增递减
随机访问迭代器：可读写，多遍扫描，支持全部迭代器运算。
13、list和forward_list的特定算法链表可以改变元素间的链接而不是真的交换它们的值来“交换”元素，因此特定算法的性能比对应的通用版本好很多。
#include<iostream>
#include<list>
using namespace std;
int main(){
list<int> lst1,lst2;
for(size_t i=1;i!=5;++i)
lst1.push_back(i);
for(size_t i=6;i!=10;++i)
lst1.push_back(i);
lst1.merge(lst2); //将lst2的元素合并入lst1，并将元素从lst2删除，lst1和lst2必须有序
for(const auto l:lst2)
cout<<l<<" ";
cout<<endl;
lst1.remove(5); //将lst1的指定元素删除
lst1.reverse(); //将lst1的元素反转
for(const auto l:lst1)
cout<<l<<" ";
cout<<endl;
list<int> lst3;
for(size_t i=20;i!=25;++i)
lst3.push_back(i);
lst1.splice(lst1.begin(),lst3);//将lst3中的所有元素移动到lst1.begin()之前的位置，并将元素从lst3删除
for(const auto l:lst1)
cout<<l<<" ";
cout<<endl;
system("pause");
return 0;
}