【C++提高编程(三)】STL函数对象及常用算法

4 STL函数对象

4.1 函数对象

4.1.1 函数对象概念

重载函数调用操作符的类，其对象常称为函数对象；函数对象使用重载的 () 时，行为类似函数调用，因此也叫仿函数。

函数对象(仿函数)是一个类，不是一个函数

4.1.2 函数对象使用

• 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
• 函数对象超出普通函数的概念，可以有自己的状态(states, 可以有自己的一些成员属性记录其状态)
• 函数对象可以作为参数传递

//定义仿函数
class Factor{
public:
    int operator()(int a){
        cout<<a<<endl;
    }
};
//普通函数
void test(Factor &f, int a){
    f(a);
}
//定义仿函数对象
Factor F;
//函数对象作为参数传递
test(F, 123);

4.2 谓词

返回bool类型的仿函数称为谓词(predicate)；如果operator()接受一个参数就称作一元谓词、接受两个参数则称作二元谓词

4.3 内建函数对象

4.3.1 内建函数对象的意义

分类：

• 算数仿函数
• 关系仿函数
• 逻辑仿函数

这些仿函数所产生的对象用法和一般函数完全相同；

**使用内建函数对象需要引入头文件 **#include <functional>

4.3.2 算数仿函数

实现四则运算，其中negate是一元运算，其他都是二元运算

template<class T> T plus<T>;		//加法仿函数
template<class T> T minus<T>;		//减法仿函数
template<class T> T multiplies<T>;	//乘法仿函数
template<class T> T divides<T>;		//除法仿函数
template<class T> T modulus<T>;		//取模仿函数
template<class T> T negate<T>;		//取反仿函数

4.3.3 关系仿函数

template<class T> bool equal_to<T>;			//等于
template<class T> bool not_equal_to<T>;		//不等于
template<class T> bool greater<T>;			//大于(最常用)
template<class T> bool greater_equal<T>;	//大于等于
template<class T> bool less<T>;				//小于
template<class T> bool less_equal<T>;		//小于等于

之前学习过的使用仿函数改变容器排序顺序的方法，也可以使用关系仿函数实现，免除了自己写仿函数

4.3.4 逻辑仿函数

template<class T> bool logical_and<T>;	//逻辑与
template<class T> bool logical_or<T>;	//逻辑或
template<class T> bool logical_not<T>;	//逻辑非

5 STL常用算法

算法主要是由头文件 <algorithm> <functional> <numeric> 组成。

• <algorithm> 是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等
• <numeric> 体积很小，只包括几个在序列上进行简单数学运算的模板函数
• <functional> 定义了一些模板类，用以声明函数对象

5.1 常用遍历算法

• for_each //遍历容器
• transform //搬运容器到另一个容器中

5.1.1 for_each (遍历)

for_each(iterator beg, iterator end, _func);

遍历算法，遍历容器元素，其中beg为起始迭代器，end为结束迭代器，_func为函数或函数对象

5.1.2 transform (搬运)

搬运一个容器到另一个容器中

transform(iterator beg1, iterator end1, iterator beg2, _func);

beg1源容器开始迭代器，end1源容器结束迭代器；beg2目标容器开始迭代器；

_func函数或函数对象

transform(v1.begin(), vi.end(), v2.begin(), 函数或仿函数);
//将容器v1中的元素全部搬运到容器v2中，在搬运过程中对每个元素都使用函数或仿函数处理(可以是算数运算，也可以是逻辑运算等);
//目标容器必须要提前开辟好足够的空间，否则无法进行搬运

5.2 常用查找算法

find			//查找元素
find_if			//按条件查找元素
adjacent_find	//查找相邻重复元素
binary_search	//二分查找法
count			//统计元素个数
count_if		//按条件统计元素个数

5.2.1 find (查找)

find(iterator beg, iterator end, value);

按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置；

只有vector容器没有实现find函数，其余常见容器都实现了find函数；且仅有string的find函数返回的是下标索引，其余都是返回迭代器。

使用find算法查找自定义数据类型时，往往需要对==操作符进行重写，需要注意的是重写时的形参应该使用const修饰，这是因为算法在判断是否符合条件时所用的右值是const修饰的形式。

//find的底层实现
template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)//第三形参为const引用，作为右值使用；非const类型可以转换成const类型
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}
//对operator==的重写至少应满足作为右值的形参为const类型，因为const类型不可以转换为非const类型
//成员函数重写
bool operator==(const class &c){}
//全局函数重写，c2作为右值
bool operator==(class &c1, const class &c2){}

5.2.2 find_if (条件查找)

find_if(iterator beg, iterator end, _Pred);

按条件查找元素，找到返回第一个满足条件的元素位置迭代器，找不到返回结束迭代器位置

_Pred 可以是函数或谓词

5.2.3 adjacent_find (相邻元素查找)

adjacent_find(iterator beg, iterator end);

查找相邻重复元素（两元素之间没有其他元素），返回相邻元素的第一个位置的迭代器

5.2.4 binary_search (二分查找)

查找效率很高， 但在无序序列中不可用，否则无法确保查找的正确性

bool binary_search(iterator beg, iterator end, value);

查找指定元素，查到返回true，否则返回search

5.2.5 count (计数查找)

count(iterator beg, iterator end, value);

统计元素出现次数。

与find类似的，在查找自定义数据类型时也需要对==运算符进行重载，也依旧需要注意使用常量引用做参数

5.2.6 count_if (条件计数查找)

count_if(iterator beg, iterator end, _Pred);

统计[beg, end)区间中符合_Pred条件的元素的出现次数

5.3 常用排序算法

sort			//对容器内元素进行排序
random_shuffle	//洗牌，指定范围内的元素随机调整次序
merge			//容器元素合并，并存储到另一容器中
reverse			//反转指定范围内的元素

5.3.1 sort (排序)

sort(iterator beg, iterator end, _Pred);

按值查找元素，找到返回指定位置迭代器，找不到返回结束位置迭代器

_Pred默认为从小到大升序排序的一个函数对象，可以自行传入其他规则的仿函数，如greater<数据类型>()可以实现降序排列

5.3.2 random_shuffle (洗牌)

random_shuffle(iterator beg, iterator end);

对指定范围内的元素随机调整次序

可以使用随机种子使每次打乱的结果都不同

#include <ctime>
srand((unsigned_int)time(NULL));

5.3.3 merge (归并)

merge(iterator beg1, iterator end1, iterator beg2, iterator end2,iterator dest)

将两个容器的元素进行合并，存储到目标容器dest中,目标容器需要提前被分配充足的空间

• 被合并的两个容器必须是有序的
• 两个排序规则不同的容器不能被归并
• 可以将仿函数作为第六个形参传入，指定被归并的两容器的排序规则

5.3.4 reverse (翻转)

reverse(iterator beg, iterator end);

翻转指定范围内的元素

5.4 常用拷贝和替换算法

copy		//将容器内指定范围的元素拷贝到另一容器中
replace		//将容器内指定范围的旧元素替换为新元素
replace_if	//将容器内指定范围满足条件的元素替换为新元素
swap		//互换两个容器的元素

5.4.1 copy (复制)

copy(iterator beg, iterator end, iterator dest);

将容器内指定范围的元素拷贝到另一容器中

5.4.2 replace (替换)

replace(iterator beg, iterator end, oldvalue, newvalue);

将区间范围内指定的旧元素替换成新元素

5.4.3 replace_if (条件替换)

replace_if(iterator beg, itertor end, _pred, newvalue);

将区间内满足条件的元素替换成新元素

5.4.4 swap (交换)

swap(container c1, container c2);

互换两个容器的元素，被交换的容器可以大小不同，但一定要是同种数据类型

5.5 常用算术生成算法

5.5.1 accumulate (累加)

accumulate(iterator beg, iterator end, value);

value表示起始的累加值(额外加到累计计算结果上的值)；

计算容器指定区间内元素的累计和并将其返回

• 使用时需要引入头文件#include <numeric>

5.5.2 fill (填充)

fill(iterator beg, iterator end, value);

向容器中的指定区域填充元素

5.6 常用集合算法

5.6.1 set_intersection (交集)

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2,iterator dest);

求两个集合的交集并返回交集的最后一个元素的迭代器地址

这两个集合必须是有序序列，目标容器dest需要提前开辟空间(最特殊情况为大容器包含小容器，此时**开辟空间的值取小容器的size()**即可)

vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin())
for_each(vTarget.begin(), itEnd, myPrint;

在使用for_each获取目标容器中的元素时最好使用迭代器指针而不是vTarget.end()，这是因为目标容器的size可能会大于实际交集的size

5.6.2 set_union (并集)

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

求两个集合的并集

两集合必须是有序序列；目标容器的大小可以被开辟为两集合的size之和

5.6.3 set_difference (差集)

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

求两个集合的差集(如求v1和v2容器的差集，即求在v1中但不在v2中的数据元素的集合)

在为目标容器开辟空间时，考虑到最坏情况为两个集合不含有任何交集，为此目标容器初始空间可以开辟为较大容器(可以使用max函数判断)的size大小

在使用for_each获取目标容器中的元素时最好使用迭代器指针而不是vTarget.end()，这是因为目标容器的size可能会大于实际差集的size