C++ 提高编程 第4.5章 STL之函数对象、常用算法

一、函数对象

1.概念

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

2.本质

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

3.函数对象使用

特点

• 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值

class myAdd
{
public:
    int operator()(int a, int b)
    {
        return a + b;
    }
};
int main() {
    myAdd myadd1;
    cout << myadd1(3, 4) << endl;
    return 0;
}

• 函数对象超出普通函数的概念，函数对象可以有自己的状态

class Myprint
{
public:
	int cnt;
	void operator()(string str)
	{
		cout << str << endl;
		this->cnt++;
	}
	Myprint()
	{
		this->cnt = 0;
	}
};

int main()
{
	Myprint print;
	for(int i=1;i<=10;i++)
	print("Hello,C++");
	cout << print.cnt << endl;
	return 0;
}

• 仿函数非常灵活，函数对象可以作为参数传递

void doPrint(Myprint& print, string str)
{
	print(str);
}
int main()
{
	Myprint print;
	for (int i = 1; i <= 10; i++)
		doPrint(print, "Hello,C++");
	cout << print.cnt << endl;
	return 0;
}

二、谓词

1.概念

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词

2.一元谓词

class GreaterFive
{
public:
	bool operator()(int x)
	{
		return x > 5;
	}
};

int main()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
		vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());//匿名对象
		if (it == v.end()) cout << "Not Found!" << endl;//o(n)寻找，返回迭代器
		else cout << *it << endl;
	}
}

3.二元谓词

class cmp
{
public:
	bool operator()(int a, int b)
	{
		return a > b;
	}
};
int main()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	sort(v.begin(), v.end(), cmp());
	for (vector<int>::iterator it = v.begin();it!=v.end();it++)
	{
		cout << *it << " ";
	}
	return 0;
}

三、内建函数对象

1.概念

STL内建了一些函数的对象

2.分类

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

3.用法

这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件#include<functional>

4.算术仿函数

实现四则运算，期中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>：取反仿函数

int main()
{
	modulus<int>mod;
	negate<double>ngt;
	cout << mod(5, 3) << endl;
	cout << ngt(19) << endl;
	return 0;
}

5.关系仿函数

函数原型

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>：小于等于

int main()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	sort(v.begin(), v.end(), greater());
	for (vector<int>::iterator it = v.begin();it!=v.end();it++)
	{
		cout << *it<< " ";
	}
	return 0;
}

6.逻辑仿函数

实现逻辑运算
template<class T> bool logical_and<T>：逻辑与
template<class T> bool logical_or<T>：逻辑或
template<class T> bool logical_not<T>：逻辑非

vector<bool>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(false);
	}
	vector<bool>v1;
	v1.resize(v.size());//扩展v1的空间
	transform(v.begin(), v.end(), v1.begin(),logical_not<bool>());//将数据从v搬运到v1的同时取反
	for (auto x : v1) cout << x << endl;
	return 0;

三、常用算法

1.常用遍历算法

遍历函数for_each

for_each(iterator beg,iterator end,_func)
_func:函数或函数对象，遍历的同时对变量进行运算

#include <iostream>
#include<algorithm>
#include<vector>
using namespace std;
class Myprint //函数对象
{
public:
	void operator()(int x)
	{
		cout << x << " ";
	}
};
void print(int x)//函数
{
	cout << x << " ";
}
int main()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(),Myprint());
	for_each(v.begin(), v.end(), print);
	return 0;
}

搬运函数transform

transform(iterator beg,iterator end,iterator target,_func)
_func：搬运的同时可以编写函数进行运算

class Myprint //函数对象
{
public:
	void operator()(int x)
	{
		cout << x << " ";
	}
};
int add(int& x)
{
	return x + 1;
}
int main()
{
	vector<int>v,v1;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(),Myprint());
	v1.resize(v.size());//提前扩展空间，否则无法正常搬运
	transform(v.begin(), v.end(), v1.begin(),add);//搬运的同时加1
	for_each(v1.begin(), v1.end(), Myprint());
	return 0;
}

2.常用查找算法

find 查找元素

find(iterator beg,iterator end,value)

find_if 按条件查找

find_if(iterator beg,iterator end,_Pred)
_Pred：函数或者谓词(返回bool类型的仿函数)

adjacent_find 查找相邻重复元素

adjacent_find(iterator beg,iterator end)
查找相邻重复元素，返回相邻元素的第一个位置的迭代器

binary_search 二分查找法

bool binary_search(iterator beg,iterator end,value)
查找指定元素，查到 返回true，否则false
注意：在无序序列中不可用

count 统计元素个数

int count(iterator beg,iterator end,value)
返回value的个数
注意：统计自定义数据类型时，需要重载==号

count_if 按条件统计元素个数

count_if(iterator brg,iterator end,_Pred)
_Pred：函数或者谓词(返回bool类型的仿函数)

3.常用排序算法

sort排序

sort(iterator beg,iterator end,_Pred)
_Pred：bool函数或谓词，改变排序规则
greater：升序

random_shuffle 洗牌：指定范围内元素随机调整次序

random_shuffle(iterator beg,iterator end)

merge 容器元素合并，并存储到另一容器中

merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
beg：原容器开始迭代器
end：原容器结束迭代器
dest：目标容器开始迭代器

reverse 反转指定范围的元素

reverse(iterator beg,iterator end)

4.常用拷贝和替换算法

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

copy(iterator beg,iterator end,iterator dest)

replace 将容器指定元素的旧元素修改为新元素

replace(iterator beg,iterator end,oldvalue,newvalue)
oldvalue：旧元素
newvalue：新元素

replace_if 容器内指定范围内满足条件的元素替换为新元素

replace_if(iterator beg,iterator end,_pred,newvalue)
_pred：谓词

swap 互换两个容器的元素

swap(container c1,container c2)

4.常用算术生成算法

算术生成算法属于小型算法，使用时包含的头文件为#include<numeric>

accumulate 计算区间内容器元素累计总和

T accumulate(iterator beg,iterator end,T init)
init：表示初始值，函数返回的是容器内的元素

fill 向元素中填充指定的元素

fill(iterator beg,iterator end,value)

5.常用的集合算法

set_intersection 求两个集合的交集

返回的是指向交集最后一个元素的迭代器
set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
注意：两个集合必须有序

int main()
{
	vector<int>v1,v2,v3;
	unsigned srand = time(0);
	for (int i = 0; i < 10; i++)
	{
		int x = rand() % 10;
		int y = rand() % 10;
		v1.push_back(x);
		v2.push_back(y);
	}
	for_each(v1.begin(), v1.end(), print);
	puts("");
	for_each(v2.begin(), v2.end(), print);
	puts("");
	v3.resize(min(v1.size(), v2.size()));
	sort(v1.begin(), v1.end());
	sort(v2.begin(), v2.end());//使用set算法时容器内元素必须有序
	vector<int>::iterator it = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(),v3.begin());
	for_each(v3.begin(), it, print);//此处必须使用函数返回的迭代器
	return 0;
}

set_union 求两个集合的并集

set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
返回的是指向并集最后一个元素的迭代器
注意：两个集合必须有序

vector<int>v1,v2,v3;
	srand(time(0));
	for (int i = 0; i < 10; i++)
	{
		int x = rand() % 10;
		int y = rand() % 10;
		v1.push_back(x);
		v2.push_back(y);
	}
	for_each(v1.begin(), v1.end(), print);
	puts("");
	for_each(v2.begin(), v2.end(), print);
	puts("");
	v3.resize(v1.size() + v2.size());//必须提前开辟最大的空间
	sort(v1.begin(), v1.end());
	sort(v2.begin(), v2.end());//使用set算法时容器内元素必须有序
	vector<int>::iterator it = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(),v3.begin());
	for_each(v3.begin(), it, print);//此处必须使用函数返回的迭代器
	return 0;

set_difference 求两个集合的差集 S1 - S2

算法set_difference可构造区间S1,S2的差集（出现于S1但不出现于S2的元素），即S1-S2
返回的是指向差集最后一个元素的迭代器
set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)

vector<int>v1, v2,v3;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	for_each(v1.begin(), v1.end(), print);
	puts("");
	for_each(v2.begin(),v2.end(), print);
	puts("");
	v3.resize(max(v1.size(), v2.size()));//提前开辟空间，应取最大值
	vector<int>::iterator it = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v3.begin());
	for_each(v3.begin(), it, print);
	return 0;