C++系列-内建函数对象

---

十五夜望月
唐 王建
中庭地白树栖鸦，冷露无声湿桂花。
今夜月明人尽望，不知秋思落谁家？

---

💢什么是内建函数对象

• 🔥内建函数对象，也称为预定义函数对象，标准库函数对象。
• 🔥内建函数对象，在<functional>头文件中定义的一组可用于各种算法和容器操作的对象。
• 🔥内建函数对象主要有算术函数对象，关系函数对象，逻辑函数对象。

💢算术函数对象

算术函数对象	描述
plus	加法函数对象
minus	减法函数对象
multiplies	乘法函数对象
divides	除法函数对象
modulus	取模函数对象
negate	取反函数对象

👉 👉 👉
其中negate是一元运算的，其余都是二元运算。
注意在下面代码中transform的参数: const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) ，前几个传递的都是迭代器。

code:
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;

void print_vector(vector<int>& vec)
{
	for (auto i_vec : vec)
	{
		cout << i_vec << " ";
	}
	cout << endl;
}

void test01()
{
	// negate举例
	negate<int>n1;
	cout << "negate, n1(5): " << n1(5) << endl;
	cout << "negate, n1(-5): " << n1(-5) << endl;
}

void test02()
{
	// 其它举例
	vector<int> vec1{11, 22, 33, 44};
	cout << "vec1: " << endl;
	print_vector(vec1);
	vector<int> vec2{1, 2, 3, 10};
	cout << "vec2: " << endl;
	print_vector(vec2);
	vector<int> result(vec1.size()); // 创建vec1.size()个元素，并将其初始化为0
	// transform的参数: const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) 
	transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), plus<int>());
	cout << "plus, result:" << endl;
	print_vector(result);

	transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), minus<int>());
	cout << "minus, result:" << endl;
	print_vector(result);

	transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), multiplies<int>());
	cout << "multiplies, result:" << endl;
	print_vector(result);

	transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), divides<int>());
	cout << "divides, result:" << endl;
	print_vector(result);

	transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), modulus<int>());
	cout << "modulus, result:" << endl;
	print_vector(result);
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

result:
negate, n1(5): -5
negate, n1(-5): 5
vec1:
11 22 33 44
vec2:
1 2 3 10
plus, result:
12 24 36 54
minus, result:
10 20 30 34
multiplies, result:
11 44 99 440
divides, result:
11 11 11 4
modulus, result:
0 0 0 4

---

💢关系函数对象

关系函数对象	描述
equal_to	判断两个值是否相等，例如查找容器中是否存在特定值
not_equal_to	不等于函数对象
greater	大于函数对象
greater_equal	大于等于函数对象
less	小于函数对象
less_equal	小于等于函数对象

👉 👉 👉
下面代码中用到any_of, any_of() 在给定的范围内迭代，并为每个元素给定的回调，即一元谓词。如果某一个元素，使得谓词的返回值我true，则停止进一步迭代并返回 true，否则返回 false。
bind1st()和bind2nd()都是把二元函数转化为一元函数，方法是绑定其中一个参数，本类中绑定第二个参数(3，想让vectror中的元素和3比)。

code:
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;

void print_vector(vector<int>& vec)
{
	for (auto i_vec : vec)
	{
		cout << i_vec << " ";
	}
	cout << endl;
}

void test01()
{
	// equal_to
	vector<int> vec1 = { 1,2,3,4,5 };
	// any_of(const _InIt _First, const _InIt _Last, _Pr _Pred)
	// equal_to: bool operator()(const _Ty& _Left, const _Ty& _Right)
	print_vector(vec1);
	bool found0 = any_of(vec1.begin(), vec1.end(), bind2nd(equal_to<int>(), 1));
	cout << "equal_to: " << found0 << endl;

	// not_equal_to
	vector<int> vec2(5, 3);
	print_vector(vec2);
	bool found1 = any_of(vec2.begin(), vec2.end(), bind2nd(not_equal_to<int>(), 3));
	cout << "not_equal_to: " << found1 << endl;

	// greater, 降序排序
	vector<int> vec3{10, 20, 100, 40, 30};
	print_vector(vec3);
	sort(vec3.begin(), vec3.end(), greater<int>());
	cout << "greater: " << endl;
	print_vector(vec3);

	// less, 升序排序
	sort(vec3.begin(), vec3.end(), less<int>());
	cout << "less: " << endl;
	print_vector(vec3);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

result:
1 2 3 4 5
equal_to: 1
3 3 3 3 3
not_equal_to: 0
10 20 100 40 30
greater:
100 40 30 20 10
less:
10 20 30 40 100

---

💢逻辑函数对象

关系函数对象	描述
logical_and	判断两个值是否相等，例如查找容器中是否存在特定值
logical_or	不等于函数对象
logical_not	大于函数对象

👉 👉 👉
下面代码中，bind2nd(logical_and(), 1)表示与1做逻辑与操作。

code:
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;

void print_vector(vector<int>& vec)
{
	for (auto i_vec : vec)
	{
		cout << i_vec << " ";
	}
	cout << endl;
}

void test01()
{
	// logical_and
	vector<int> vec1 = { 0,2,3,0,5 };
	cout << "---------- vec1 ----------" << endl;
	print_vector(vec1);
	vector<int> vec2(vec1.size());
	// bind2nd(logical_and<int>(), 1)实现与1的逻辑与操作
	transform(vec1.begin(), vec1.end(), vec2.begin(), bind2nd(logical_and<int>(), 1));
	cout << "---------- logical_and 1, vec2 ----------" << endl;
	print_vector(vec2);

	transform(vec1.begin(), vec1.end(), vec2.begin(), bind2nd(logical_or<int>(), 1));
	cout << "---------- logical_or1, vec2 ----------" << endl;
	print_vector(vec2);

	transform(vec1.begin(), vec1.end(), vec2.begin(), logical_not<int>());
	cout << "---------- logical_not, vec2 ----------" << endl;
	print_vector(vec2);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- vec1 ----------
0 2 3 0 5
---------- logical_and 1, vec2 ----------
0 1 1 0 1
---------- logical_or1, vec2 ----------
1 1 1 1 1
---------- logical_not, vec2 ----------
1 0 0 1 0