C++primer第五版笔记-第十章泛型算法

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

accumulate的第三个参数决定了函数中使用哪个加法运算符以及返回值的类型

//接受三个迭代器，前两个和以前一样，表示第一个序列中的元素范围，第三个表示第二个序列的收元素equal(vi.cbegin(),vi.cend(),v2.cbegin());

写容器元素的算法：

fill(vi.begin(), vi.end(), 0);//将每个元素赋值为0fill(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);

介绍back_inseter

通常情况下，当我们通过一个迭代器向容器元素赋值时，值被赋予迭代器指向的元素，而当我们通过一个插入迭代器赋值时，一个与赋值号右侧值相等的元素被添加到容器中。

    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读入一个序列，并将其中所有给定值的元素都改为另一个值

    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_sizeauto 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是一个局部变量，类型为charfor_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 1copy(lst.cbegin(),lst.cend(),front_insert(lst2));//拷贝完成后，lst3包含1 2 3 4 copy(lst.cbegin(),lst.cend(),inserter(lst3,lst3.begin()));

iostream迭代器

istream_iterator<int> int_it(cin);//从cin读取intistream_iterator<int> int_eof;//尾后迭代器ifstream in('afile');istream_iterator<string> str_it(in);//从‘afile’中读取istream_iterator<int> in_iter(cin);//从cin中读取intistream_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;//赋值语句实际上将元素写到coutcout<<endl;//等同下面语句for(auto e:vec);cout<<ednl;

5、泛型算法结构

6、特定容器算法

//调用erase删除掉给定值相等或另一元谓词为真的每个元素lst.remove(val) ；lst.remove_if(pred);lst.reverse();//翻转lstlst.sort();//使用<或给定的比较操作排序元素lst.sort(comp);lst.unique();//调用erase删除同一个值的连续拷贝lst.unique(pred);