10-泛型算法

10.1 概述

#include //大部分算法定义

#include //数值泛型算法  

容器查找

auto ret = find(v.cbegin(), v.cend(), val);

if (ret == v.cend()){

//未找到

}else{

//找到，ret指向第一个找到的元素的迭代器

}

find(begin(arr), end(arr), val);  //内置数组

算法运行于迭代器之上，依赖于迭代器支持的迭代器操作。泛型算法不会改变底层容器的大小，不会直接添加和删除元素。

10.2 初识泛型算法

大部分算法对一个范围内的元素进行操作，[begin, end)，一般是前两个参数。

10.2.1 只读算法

只读取范围内的参数，不改变元素。例如find。

#include

int sum = accumulate(v.cbegin(), v.cend(), val); //对v中元素求和，和的初值为val。

v的元素必须支持加到val上的操作，类型匹配或者可以转换。

equal(r1.cbegin(), r1.cend(), r2.cbegin()); //对r1,r2中相应位置元素比较，所有对应元素相等返回true。

对于容器和元素的类型没有强制要求相同，只需支持用==比较即可。假定r2的待比较序列的长度至少与r1一样长。

10.2.2 可写容器元素算法

fill(v.begin(), v.end(), val);//注意操作范围应有效。

fill_n(v.begin(), v.size(), val);

fill_n(pos, n, val);

以上的操作需保证v的空间足够，因为普通的迭代器不会改变容器的空间。

插入迭代器：一种向容器中添加元素的迭代器。

#include

//例如

vector vec;

auto it = back_inserter(vec);

*it = 42;

//

fill_n(back_inserter(vec), n,  0);//添加n个元素到容器中，底层调用push_back()

copy(begin(arr1), end(arr2), arr2);//将数组arr1特定位置元素拷贝到arr2数组中，返回arr2尾元素之后的位置

replace(l.begin(), l.end(), origal_val, val);//原序列改变

replace_copy(l.cbegin(), l.cend(), back_inserter(vec), origal_val, val);//原序列未改变，修改后的版本存入vec中

10.2.3 重排容器元素算法

sort(v.begin(), v.end());//利用元素类型的<运算符实现排序

unique(v.begin(), v.end());//返回指向不重复区域之后的位置的迭代器，不改变容器大小

erase(pos_begin， pos_end);//删除，会改变容器大小

10.3 定制操作

10.3.1 向算法传递函数

谓词：可调用表达式，返回结果是一个可以用作条件的值。

一元谓词：只接受一个参数

二元谓词：只接受二个参数

使用谓词参数的算法对输入序列的每个元素调用谓词，元素类型可转换为谓词参数的类型

bool isShorter(const string &s1, const string, &s2){

        return s1.size() < s2.size();

}

sort(v.begin(), v.end(), isShorter);

stable_sort(v.begin(), v.end(), isShorter);//稳定排序，维持相等元素的原有顺序

10.3.2 lambda表达式

可调用对象：可使用调用运算符()的表达式（函数，函数指指针，lambda）

[capture list] (parameter list) -> return type { function body }

捕获列表：捕获lambda所在函数中定义的局部变量的列表。

如果忽略返回类型，若函数体只有一个return语句，则根据语句推断出返回类型；否则，返回void;可忽略参数列表和返回类型。

auto f = [] {return 42;};

cout << f() <

lambda不可有默认参数。

stable_sort(v.begin(), v.end(),[](const string &a, const string &b){ return a.size() < b.size(); });

auto f = [sz](const string&a) { return a.size() >= sz;  };

find_if(v.begin(), v.end(), f);//找出第一个返回

for_each(v.begin(), v.end(), [] (const string &s) { cout <

10.3.3 lambda 捕获和返回

当定义一个lambda时，编译器生成一个与lambda对应的类类型和此类型的对象。传递给函数的参数即是此类的未命名对象，捕获成员即是此类的数据成员。

值捕获：[val]，val的值是在lambda被创建时绑定的

引用捕获：[&val]，实际使用的是引用绑定的对象

[&os, c] (const string &s) { os << s << " ";};

隐式捕获

[=]，值捕获所有的局部非static变量

[&]，引用捕获所有的局部非static变量

总结捕获方式：

---

[ ]

[name_list]

[&]

[=]

[=,name_list]，name_list采用引用捕获，不包括this

[&,name_list]，name_list采用值捕获

---

可变lambda

[v1] () mutable { return ++val; };//可改变值捕获变量的值

指定lambda返回类型

transform(v.begin(), v.end(), v.begin(), [] (int i) { return i<0 ? -i : i; });

transform(begin(c), end(c), begin(c), [](int i)->int {

if (i < 0) {

return i;

}

else {

return -i;

}

});

10.3.4 参数绑定

#include

bind函数可视为一个通用的函数适配器，接受一个可调用对象，生成一个新的可调用对象，来适应原对象的参数列表。(修正参数或改变参数顺序)

auto newCallable = bind(callable, arg_list);

占位符 _n

using std::placeholders::_1;

using namespace std::placeholders;

_1为newCallable的第一个参数，_2为第二个参数，以此类推。

auto func1 = bind(func, _1,val);

func1(arg);//func1调用func，类似于func(arg,val);

find_if(v.begin(), v.end(), bind(func, _1, other));

auto g = bind(f, a,b,_2,c,_1);

g(d,e);等价于f(a,b,e,c,d);

绑定引用参数

默认情况下，bind的非占位符参数被拷贝到bind的返回的可调用对象中。传递对象但不拷贝，可用引用绑定。

for_each(v.begin(), v.end(), bind(print, ref(os),_1, ' '));

#include

ref(os);返回一个对象，包含os的引用，可拷贝。

cref(os);生成一个保存const引用的类。

10.4 再探迭代器

插入迭代器：被绑定到一个容器上，用来向容器插入元素

流迭代器：绑定到输入输出流，用来遍历关联的IO流

反向迭代器：向后移动，除forward_list标准库容器都有此迭代器

移动迭代器：不拷贝容器的元素，只是移动

10.4.1 插入迭代器

使用插入迭代器赋值，迭代器调用容器操作给给定容器的指定位置插入一个元素。

支持的操作：

it = t; //it为插入迭代器，插入t到it指向的位置

*it, ++it, it++ //不会执行实际操作，返回it

---

back_inserter:创建一个使用push_back的迭代器

front_inserter:创建一个使用push_front的迭代器

inserter:创建一个使用insert的迭代器

---

auto it = inserter(c, iter);

*it = val;//将val插入到iter指向元素之前的位置，it指向原来的元素位置

等价于

it = c.insert(it, val);

++it;

back_inserter，front_inserter迭代器插入后会改变当前迭代指向的位置，而inserter迭代器不会。

与普通的迭代器的区别是：算法可以间接的改变容器的大小。

10.4.2 iostream迭代器

此种迭代器将关联的流当做一个特定类型的元素序列来处理,便于使用泛型算法。istream_iterator关联的类型需支持>>运算符,ostream_iterator关联的类型必须支持<<运算符。

流迭代器不支持--运算。

允许使用懒惰求值，在我们第一次解引用迭代器之前，数据就已经从流中读取出来了。

---

istream_iterator  int_it(cin);//从cin读取int

istream_iterator it_eof;//默认初始化迭代器生成尾后迭代器

int_it1 == int_it2;

int_it1 != int_it2;

*int_in;

int_in->men(或(*int_in).men)

++int_it;//使用元素类型定义的>>读取流中下一个值

int_it++;

例子：

ifstream in("path");

istream_iterator str_in(in);

while (int_in != it_eof){

v.push_back(*int_it++);

}

vector vec(int_it, it_eof);//将流的数据初始化vector

---

ostream_iterator out(os);//将类型T的元素写入到os中

ostream_iterator out(os, d);//每写一个元素就附加一个d，d指向一个C风格的字符串数组

out  = val;//将val写入到out关联的流中

*out ,++out , out++ 不对out执行任何操作，返回out

例子：

ostream_iterator out_it(cout, '" ");

for (auto e : vec){

*out_it++ = e;//输出vec的元素到cout中，等价于out_it=e

}

copy(vec.begin(), vec.end(), out_it);//打印vec元素到cout中

cout<

10.4.3 反向迭代器

容器中从尾元素向首元素移动的迭代器。

rbegin, rend, crbegin, crend.

iter = riter.base();//返回一个普通的迭代器，riter，iter的位置是相邻的

10.5 泛型算法结构

算法要求的迭代器操作分为5个迭代器类别，

输入迭代器：只读；单遍扫描，递增

输出迭代器：只写；单遍扫描，递增

前向迭代器：可读写，多遍扫描，递增

双向迭代器：可读写；多遍扫描，递增递减

随机访问迭代器：可读写；多遍扫描，支持所有迭代器操作

10.5.1 

对泛型和数值算法来说，迭代器参数的能力必须与算法规定的迭代器最小类别的至少相当。

10.5.2 算法形参模式

大部分算法具有如下形式：

alg(beg, end, arg_list);

alg(beg, end, dest, arg_list);

alg(beg, end, beg2, arg_list);

alg(beg, end, beg2, end2, arg_list);

10.5.3 算法命名规范

接受谓词参数来代替<或==运算符的算法，以及不接受额外参数的算法，通常都是重载的函数。一个版本使用元素类型的运算符来比较，另一个版本使用谓词参数代替<或==；

接受一个元素值的算法通常有一个附加_if的函数（非重载）。一般是在给定范围查找元素第一次出现的位置。

某些算法会将对元素的操作写回原容器，一般附加_copy的算法会将操作执行早附加的目标容器，而不改变原容器。

10.6 特定容器算法

list和forward_list的特定成员函数算法

lst.merge(list2);//lst2合并到lst中，都需要有序,lst2最后变为空，使用元素的<

lst.merge(lst2, comp);//使用comp比较

lst.remove(val);//调用erase删除val

lst.remove_if(pred);//调用erase删除谓词为真的元素

lst.reverse()；//翻转lst

lst.sort()

lst.sort(comp)

lst.unique();//调用erase删除同一个值得连续拷贝，使用==

lst.unique(pred);//使用给定二元谓词

lst.splice(args)或flst.splice_after(args)

参数args类型：

(p, lst2)：将lst2的所有元素移动到lst中p指向的位置或flst中p之后的位置，lst2之后为空，不可为同一个链表

(p, lst2, p2)：将p2指向lst2的元素移动到lst中或p2之后的移动到flst中，lst2可以是与lst或flst相同的链表

(p, lst2, b, e)：将lst2的[b, e)范围的元素移动到lst或flst，可与lst或flst是相同的链表，p不可以指向此范围的元素。

链表特有的算法会改变容器，与通用版本有区别。