C++算法——函数对象\谓词\内置仿函数

目录

函数对象：

函数对象的定义： 

函数对象的本质：

函数对象的特点：

谓词

谓词的形式： 

内置函数对象

算法仿函数

关系仿函数

逻辑仿函数

---

函数对象：

函数对象的定义： 

C++的函数对象是一个类的实例，其可以像函数一样被调用，并且可以保存状态。

函数对象重载了()运算符，允许其被当做函数来调用。

函数对象的本质：

是一个类对象

函数对象的特点：

1. 行为类似于函数：函数对象可以被调用，就像调用函数一样，可以接受参数并返回结果。
2. 状态保持：函数对象可以在调用之间保持状态。因为函数对象是类的对象，可以在类的成员变量中保存状态信息，在多次调用中可以保持这些状态。
3. 高效性：函数对象的调用比函数指针的调用更高效，因为函数对象可以进行内联操作，无需进行函数调用的开销。

简单使用函数对象：

#include<iostream>

class first
{
public:
	int operator()(int a, int b)
	{
		count++;
		return a - b;
	}
	int count{ 0 };
};

int main()
{
	first a;
	std::cout << a(9, 8)<<std::endl;
	std::cout << a(9, 4) << std::endl;
	std::cout << a.count;
	return 0;
}

//输出结果是
1
5
2

谓词

谓词是一个函数或函数对象，它接受一个或多个参数，并返回一个布尔值。

谓词通常被用作某个操作的判断条件，返回 true 表示满足条件，返回 false 表示不满足条件。

谓词的形式： 

有五种

1. 普通函数：这是一个简单的函数，接收一个或多个参数，并返回一个布尔值。
2. 函数指针：指向一个返回布尔值的函数的指针。
3. 函数对象：这是重载了()操作符的类的实例，使得它可以像函数一样被调用，并返回布尔值；这类对象也被称为“仿函数”。
4. Lambda表达式：匿名函数，可以直接在代码中定义并创建，常用于临时性、一次性使用的判断逻辑。
5. 库定义的函数对象：STL等库中预定义的一些类，这些类的对象也可以作为谓词使用

函数对象的谓词的使用举例说明：

#include<iostream>
#include<algorithm>
#include<vector>
class first
{
public:
	bool operator()(int a, int b)
	{
		return a > b;
	}
};

int main()
{
	first a;
	std::vector<int>b{2,3,4,77,45};
	std::sort(b.begin(), b.end(), a);
	for (auto i = b.begin(); i != b.end(); i++)
	{
		std::cout << *i << " ";
	}
	return 0;
}

//输出的结果是
77 45 4 3 2

内置函数对象

 C++标准库提供了一些内置的函数对象，用于在算法函数中方便地实现通用的操作，这些函数对象通常用作谓词或其他函数对象的基础

算法仿函数

std::plus<T>：加法函数对象，用于执行两个值的加法操作。

std::plus<int> add;
int result = add(5, 3); // 返回 8

std::minus<T>：减法函数对象，用于执行两个值的减法操作。

std::minus<int> s;
int result = s(10, 3); // 返回 7

std::multiplies<T>：乘法函数对象，用于执行两个值的乘法操作。

std::multiplies<int> m;
int result = m(4, 5); // 返回 20

std::divides<T>：除法函数对象，用于执行两个值的除法操作。

std::divides<double> d;
double result = d(10.0, 2.0); // 返回 5.0

std::modulus<T>：取模函数对象，用于执行两个值的取模操作。

std::modulus<int> modulus;
int result = modulus(10, 3); // 返回 1

std::negate<T>：取反函数对象，用于执行一个值的取反操作。

std::negate<int> negate;
int result = negate(8); // 返回 -8

关系仿函数

std::less<T>：比较小于关系的函数对象，用于确定一个值是否小于另一个值。

std::less<int> less_than;
bool result = less_than(3, 5); // 返回 true

std::less_equal<T>：比较小于等于关系的函数对象，用于确定一个值是否小于或等于另一个值。

std::less_equal<int> less_equal;
bool result = less_equal(4, 4); // 返回 true

std::greater<T>：比较大于关系的函数对象，用于确定一个值是否大于另一个值。

std::greater<int> greater_than;
bool result = greater_than(7, 3); // 返回 true

std::greater_equal<T>：比较大于等于关系的函数对象，用于确定一个值是否大于或等于另一个值。

std::greater_equal<int> greater_equal;
bool result = greater_equal(6, 6); // 返回 true

std::equal_to<T>：比较相等关系的函数对象，用于确定两个值是否相等。

std::equal_to<int> equal;
bool result = equal(10, 10); // 返回 true

std::not_equal_to<T>：比较不等关系的函数对象，用于确定两个值是否不相等。

std::not_equal_to<int> not_equal;
bool result = not_equal(3, 6); // 返回 true

逻辑仿函数

std::logical_and<T>：逻辑与函数对象，用于执行逻辑与运算。

std::logical_and<bool> logical_and;
bool result = logical_and(true, false); // 返回 false

std::logical_or<T>：逻辑或函数对象，用于执行逻辑或运算。

std::logical_or<bool> logical_or;
bool result = logical_or(true, false); // 返回 true

std::logical_not<T>：逻辑非函数对象，用于执行逻辑非运算。

std::logical_not<bool> logical_not;
bool result = logical_not(true); // 返回 false