C++学习整理（泛型算法）

泛型算法

1、算法一般情况下，不直接操作容器，而是遍历由两个迭代器指定的一个元素范围来进行操作。

//////find返回第二个参数表示收索失败
int val = 42;
auto result = find(vec.begin(),vec.end(),val);
int a[] = {1,23,4,56,7,90};
int * result1 = find(begin(a),end(a),val);

2、只读算法：find、count、equal、accumulate（头文件numeric）

accumulate

/////第三个参数类型决定了函数中使用哪种加法和返回值类型
int result = accumulate(vec.begin(),vec.end(),0);
string num = accumulate(v.cbegin(),v.cend(),string(""));
/////""为const char * 类型，没有定义+运算符，错误
string num2 = accumulate(v.cbegin(),v.cend(),"");

3、写容器的算法：fill,fill_n,back_inserter,copy,replace,replace_copy

fill

////算法不会执行容器操作，因此它们自身不可能改变容器的大小；
fill(vec.begin(),vec.end(),0);

fill_n

vector<int> vec;
fill_n(vec.begin(),vec.end(),0);//所有元素重置为0
fill_n(dest,n,val);//dest指向一个元素，从dest开始的序列至少包含n个元素
////在没有足够多的元素的vec中使用fill_n是错误的
vector<int> v;
fill_n(v,10,0);

back_inserter:插入迭代器，执行赋值运算时，会调用push_back将一个具体给定的值元素添加到容器中

///正确
vector<int> v;
fill_n(back_inserter(v),10,0)

replace、replace_copy

///注意两者的区别
replace(list.begin(),list.end(),0,42);
replace_copy(list.begin(),list.end(),back_inserter(vec),0,42);

4、重排容器算法：sort，unique

unique

///删除vstr中重复的元素
void deleteTheComWords(vector<string> &vstr){
sort(vstr.begin(),vstr.end());
//返回指向不重复区域之后一个位置的迭代器
auto end_unique = unique(vstr.begin(),vstr.end());
//标准库算法对迭代器而不是对容器进行操作，因此不能直接添加或删除元素
vstr.erase(end_unique,vstr.end());
}

5、定制操作

向算法传递函数（一般指谓词）

sort具有操作版本接受第三个参数：二元谓词

///程序一
bool bigger(int a,int b){
return a > b;
}
int main()
{
vector<int> v = {1,5,3,6,4};

ostream_iterator<int> out_iter(cout," ");
copy(v.begin(),v.end(),out_iter);

cout << endl;
//sort(v.begin(),v.end());//从小到大
sort(v.begin(),v.end(),bigger);//从大到小
copy(v.begin(),v.end(),out_iter);
return 0;
}

lambda表达式（C++11）

①[捕获列表](参数列表) -> 返回值类型 {函数主体} （可以忽略参数列表和返回值）

////程序二
//删除重复单词、排序打印vector中长度大于sz的元素
void bigger(vector<string> &words,vector<string>::size_type sz){
sort(words.begin(),words.end());
auto end_unique = unique(words.begin(),words.end());
words.erase(end_unique,words.end());
//在按照长度稳定排序
stable_sort(words.begin(),words.end(),[](const string &s1,const string $s2){return s1.size() < s2.size();});
//获取满足大于sz的迭代器
auto wc = find_if(words.begin(),words.end(),[sz](const string &s){return s.size() >= sz;});
//打印结果
for_each(wc,words.end(),[](const string &s){cout << s << " ";});
cout << endl;
}

*stable_sort算法：可维持相等元素的原有顺序;

*lambda表达式中的捕获列表只能用于局部非static变量（sz），可直接使用局部static变量

②捕获列表：

////程序三
//值捕获方式：前提变量可拷贝；被捕获变量的值是在lambda创建时拷贝，而不是调用时拷贝
void fun1(){
int a = 42;
auto f = [a]{return a;};
a = 0;
auto j = f();//j = 42;f保持了a的拷贝
}
//引用捕获方式：
void fun2(){
int a = 42;
auto f = [&a]{return a;};
a = 0;
int j = f();//j为0
}
//隐式捕获：在捕获列表中使用=或&，表示值捕获和应用捕获
void printbigger(vector<int> vec,int bigger,ostream &os = cout, char c = ' '){
//隐式捕获os,显示捕获c
for_each(vec.begin(),vec.end(),[&,c](const int & i){os << i << c;});
for_each(vec.begin(),vec.end(),[=,&os](const int & i){os << i << c;});
}
//可变的lambda
void fcn3(){
int v1 = 42;
auto f = [v1]() mutable {return ++v1;};
v1 = 0;
auto j = f();//j = 43
}

③指定lambda的返回值

////程序四
//返回一个条件表达式，编译器可以推断返回类型
transform(v.begin(),v.end(),v.begin(),[](int i){return i < 0 ? -i:i;});
//将会产生错误不能推断具体的返回类型
transform(v.begin(),v.end(),v.begin(),[](int i){if (i < 0) return -i;else return i;});
//正确
transform(v.begin(),v.end(),v.begin(),
[](int i) -> int
{if (i < 0) return -i;else return i;});

参数绑定（将多元谓词转化为一元谓词）

////程序5
//二元谓词
bool check_size(const string &s,string::size_type sz){
return s.size() > sz;
}
auto check5 = bind(check_size,_1,5);//_1为占位符;using namespace std::placeholders;
string s = "hello";
bool b = check5(s);//=>check_size(s,5)

6、头文件iterator中的迭代器

插入迭代器

*back_inserter <==> push_back
*front_inserter <==> push_front
*inserter <==> 元素被插入到给定迭代器之前

list<int> lst = {1,2,3,4};
list<int> lst1,lst2;
copy(lst.begin(),lst.end(),front_inserter(lst1));//4 3 2 1
copy(lst.being(),lst.end(),inserter(lst2,lst2.begin()));//1 2 3 4

////程序6
//将vector中不重复的元素copy到list中
void v2l(vector<int> &v,list<int> &l){
sort(v.begin(),v.end());
unique_copy(v.begin(),v.end(),inserter(l,l.begin()));
}

int main()
{
vector<int> v = {1,5,3,6,4,5,8,2,3};
list<int> l;
v2l(v,l);
ostream_iterator<int> out_iter(cout," ");
copy(l.begin(),l.end(),out_iter);
cout<<endl;
return 0;
}

输入输出迭代器

*输出迭代器（ostream_iterator）在程序6中使用过了

*输入迭代器（istream_iterator）

////程序7
void testistream_iter()
{
vector<int> vec;
ostream_iterator<int> out_iter(cout," ");

istream_iterator<int> in_iter(cin);

istream_iterator<int> eof;//结束标志
while (in_iter != eof)//输入非数字时结束
vec.push_back(*in_iter++);
copy(vec.begin(),vec.end(),out_iter);
}

参考C++Primer